# Sustainable Travel Certification Tracker (`trovevault/sustainable-travel-certification-tracker`) Actor

Extracts sustainable travel certifications, properties, locations, business types, statuses, and official listing URLs. Export data, run via API, schedule and monitor runs, or integrate with other tools.

- **URL**: https://apify.com/trovevault/sustainable-travel-certification-tracker.md
- **Developed by:** [Trove Vault](https://apify.com/trovevault) (community)
- **Categories:** Travel, Real estate, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.85 / 1,000 hotels

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Sustainable Travel Certification Tracker

Find officially listed sustainable travel certifications for hotels, accommodations, destinations, and tourism businesses by location. This actor checks public certification directories such as Green Key and Travelife, normalizes matching listings, and returns a clean dataset that can be used for market research, destination analysis, travel planning, supplier discovery, and sustainability monitoring.

### Why use this actor

Sustainability claims are easy to make and hard to compare. Certification directories help, but they are split across different programs, formats, and country pages. This actor turns those public listings into structured rows with property names, business types, locations, certification names, statuses, official listing links, and website links when available.

Use it to:

- discover certified accommodations in a country or destination
- compare sustainable hotel supply across markets
- monitor certified supplier coverage for travel portfolios
- build lead lists for responsible tourism partnerships
- enrich internal hotel, destination, or operator databases
- verify that a property appears in an official certification directory

### What it extracts

The actor returns one row per certified business or property:

- property name
- business type
- certification program
- certification status
- country, region, city, and address when available
- website when listed
- official certification listing URL
- last checked timestamp
- optional run ID for workflow chaining

### Supported certifications

The first version focuses on public, official or program-owned directories:

- Green Key certified sites
- Travelife certified accommodation
- EarthCheck input compatibility

EarthCheck may require access to a gated downloadable directory. When a selected source cannot be accessed from public pages, the actor records that limitation in `RUN_SUMMARY` instead of adding uncertain public rows.

### Limitations

This actor does not certify businesses itself. A row means that the business appeared in an official or program-owned public listing during the run. Directory layouts, monthly downloads, country pages, and public access rules can change. Some sources may not expose full address or website data for every property.

Rainforest Alliance is not included in the first implementation because its public certified directory is currently more product and brand oriented than travel-accommodation oriented. It can be added later if a stable official tourism directory is identified.

### How to use it

1. Add one or more countries or destinations in `locations`.
2. Select one or more certification programs.
3. Set `maxResults` to control run size.
4. Run the actor and export the dataset as JSON, CSV, Excel, or via API.

### Input example

```json
{
  "locations": ["Portugal", "Spain"],
  "certifications": ["green_key", "travelife"],
  "maxResults": 50
}
````

### Input reference

| Field | Type | Description |
| --- | --- | --- |
| `locations` | array | Countries or destinations to search, such as `Portugal`, `Spain`, or `Costa Rica`. |
| `certifications` | array | Certification programs to include: `green_key`, `travelife`, or `earthcheck`. |
| `maxResults` | integer | Maximum number of dataset rows to return. |
| `proxyConfiguration` | object | Optional Apify proxy settings for blocked public directory requests. |
| `datasetId` | string | Optional existing Apify dataset ID to append results to. |
| `runId` | string | Optional workflow run ID copied into each output row. |

### Output example

```json
{
  "propertyName": "Neat Hotel Avenida",
  "businessType": "Hotel or Resort",
  "certification": "Travelife",
  "certificationStatus": "certified",
  "country": "Portugal",
  "region": "Região Autónoma dos Açores",
  "city": "São Miguel",
  "address": "Rua Dr. Jose Bruno Tavares Carreiro, São Miguel, Região Autónoma dos Açores",
  "website": "https://example-hotel.com",
  "certificationPageUrl": "https://staybetterplaces.com/neat-hotel-avenida/",
  "lastCheckedAt": "2026-05-06T10:00:00.000Z",
  "runId": null
}
```

### API usage

```bash
curl "https://api.apify.com/v2/acts/trovevault~sustainable-travel-certification-tracker/runs?waitForFinish=120" \
  -X POST \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "locations": ["Portugal"],
    "certifications": ["green_key", "travelife"],
    "maxResults": 20
  }'
```

### FAQ

#### Does this actor verify sustainability claims?

It verifies whether a business appears in an official or program-owned certification listing. It does not audit the business directly.

#### Why are some fields blank?

Certification directories vary. Some list only names and countries; others include address, website, region, or business type.

#### Can I use city names?

Country names are the most reliable input. Destination names can match when the source exposes that text, but coverage depends on the certification directory.

#### Why is EarthCheck sometimes missing?

EarthCheck provides a public members directory flow, but access to the downloadable list may require form submission. The actor avoids inventing rows from non-official sources.

#### Does the actor include Rainforest Alliance?

Not in v1. The public Rainforest Alliance directory currently focuses on products and brands rather than travel accommodation certification.

#### Can I schedule this actor?

Yes. Schedule it weekly or monthly to monitor certified supply by market. Use `datasetId` to append runs into a long-term dataset.

#### Can I combine results with my own pipeline?

Yes. Provide `datasetId` to append rows to an existing dataset and `runId` to tag rows from an upstream workflow.

### Troubleshooting

If a run returns fewer rows than expected, check that your locations match country names used by certification directories. If a source is blocked or unavailable, the actor records diagnostics in the `RUN_SUMMARY` key-value store record. For HTTP 403 or 429 responses, retry with Apify Proxy enabled.

### Related actors

This actor works well with hotel enrichment, destination intelligence, review monitoring, and supplier database workflows.

### Changelog

- `0.1` Initial TroveVault release with Green Key and Travelife directory extraction.

### Support

Open an issue on the actor page or contact TroveVault with the input used, run ID, and expected certification source.

# Actor input Schema

## `locations` (type: `array`):

Countries or destinations to search for certified sustainable travel businesses. The actor matches these values against official certification directories and returns certified properties in matching places. Use country names such as `Portugal`, `Spain`, or `Costa Rica` for the most reliable results. Add multiple locations to compare certified supply across markets. More locations create more directory requests and may take longer.

## `certifications` (type: `array`):

Sustainability certification programs to include. The actor searches official or program-owned directories for selected certifications and normalizes matching listings into one dataset. Use `Green Key` for broad tourism establishments and `Travelife` for certified accommodation providers. `EarthCheck` is accepted for compatibility, but public directory access may require a downloadable gated list, so it can be reported as unavailable in the run summary.

## `maxResults` (type: `integer`):

Maximum number of certified business rows to return across all selected locations and certifications. The actor stops adding rows once this limit is reached, while still writing a run summary with source diagnostics. Use 5 to 20 for quick tests, 50 to 200 for market research, and higher values for larger destination inventories. Higher values give broader coverage but take longer.

## `proxyConfiguration` (type: `object`):

Proxy settings for public certification directory requests. The actor uses normal HTTP requests first and soft-fails blocked sources into the run summary. Enable Apify Proxy only if a certification directory returns HTTP 403, 429, CAPTCHA, or regional blocking. Leave it disabled for normal runs to keep costs lower.

## `datasetId` (type: `string`):

ID of an existing Apify dataset to append results to, in addition to the default run dataset. Use this for scheduled sustainable travel certification monitoring pipelines that combine multiple runs into one long-term dataset. Leave blank to write only to the default run dataset.

## `runId` (type: `string`):

ID of an existing Apify actor run to associate results with. The actor copies this value into each dataset row so external workflows can connect certified travel inventory to an upstream job, client account, or monitoring batch. Leave blank for standalone runs.

## Actor input object example

```json
{
  "locations": [
    "Portugal"
  ],
  "certifications": [
    "green_key",
    "travelife"
  ],
  "maxResults": 5,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

# 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 = {
    "locations": [
        "Portugal"
    ],
    "certifications": [
        "green_key",
        "travelife"
    ],
    "maxResults": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("trovevault/sustainable-travel-certification-tracker").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 = {
    "locations": ["Portugal"],
    "certifications": [
        "green_key",
        "travelife",
    ],
    "maxResults": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("trovevault/sustainable-travel-certification-tracker").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "locations": [
    "Portugal"
  ],
  "certifications": [
    "green_key",
    "travelife"
  ],
  "maxResults": 5
}' |
apify call trovevault/sustainable-travel-certification-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=trovevault/sustainable-travel-certification-tracker",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Sustainable Travel Certification Tracker",
        "description": "Extracts sustainable travel certifications, properties, locations, business types, statuses, and official listing URLs. Export data, run via API, schedule and monitor runs, or integrate with other tools.",
        "version": "0.1",
        "x-build-id": "ZrwMYnYJ55Yh2r0Ld"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/trovevault~sustainable-travel-certification-tracker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-trovevault-sustainable-travel-certification-tracker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/trovevault~sustainable-travel-certification-tracker/runs": {
            "post": {
                "operationId": "runs-sync-trovevault-sustainable-travel-certification-tracker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/trovevault~sustainable-travel-certification-tracker/run-sync": {
            "post": {
                "operationId": "run-sync-trovevault-sustainable-travel-certification-tracker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "locations"
                ],
                "properties": {
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Countries or destinations to search for certified sustainable travel businesses. The actor matches these values against official certification directories and returns certified properties in matching places. Use country names such as `Portugal`, `Spain`, or `Costa Rica` for the most reliable results. Add multiple locations to compare certified supply across markets. More locations create more directory requests and may take longer.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "certifications": {
                        "title": "Certifications",
                        "type": "array",
                        "description": "Sustainability certification programs to include. The actor searches official or program-owned directories for selected certifications and normalizes matching listings into one dataset. Use `Green Key` for broad tourism establishments and `Travelife` for certified accommodation providers. `EarthCheck` is accepted for compatibility, but public directory access may require a downloadable gated list, so it can be reported as unavailable in the run summary.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "green_key",
                                "travelife",
                                "earthcheck"
                            ],
                            "enumTitles": [
                                "Green Key",
                                "Travelife",
                                "EarthCheck"
                            ]
                        }
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of certified business rows to return across all selected locations and certifications. The actor stops adding rows once this limit is reached, while still writing a run summary with source diagnostics. Use 5 to 20 for quick tests, 50 to 200 for market research, and higher values for larger destination inventories. Higher values give broader coverage but take longer.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings for public certification directory requests. The actor uses normal HTTP requests first and soft-fails blocked sources into the run summary. Enable Apify Proxy only if a certification directory returns HTTP 403, 429, CAPTCHA, or regional blocking. Leave it disabled for normal runs to keep costs lower.",
                        "default": {
                            "useApifyProxy": false
                        }
                    },
                    "datasetId": {
                        "title": "Dataset ID (optional)",
                        "type": "string",
                        "description": "ID of an existing Apify dataset to append results to, in addition to the default run dataset. Use this for scheduled sustainable travel certification monitoring pipelines that combine multiple runs into one long-term dataset. Leave blank to write only to the default run dataset."
                    },
                    "runId": {
                        "title": "Run ID (optional)",
                        "type": "string",
                        "description": "ID of an existing Apify actor run to associate results with. The actor copies this value into each dataset row so external workflows can connect certified travel inventory to an upstream job, client account, or monitoring batch. Leave blank for standalone runs."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
