# Sncf Connect (`flo.cl25spt/apify-sncfconnector`) Actor

Scrapper for sncf connect

- **URL**: https://apify.com/flo.cl25spt/apify-sncfconnector.md
- **Developed by:** [KOSMIX](https://apify.com/flo.cl25spt) (community)
- **Categories:** Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## SNCF Connect Journeys Scraper

### Que fait le SNCF Connect Journeys Scraper ?

Le **SNCF Connect Journeys Scraper** recherche sur [SNCF Connect](https://www.sncf-connect.com/) les **trajets en train entre deux villes ou gares** et extrait pour chaque offre des données structurées : horaires de départ et d'arrivée, durée du trajet, nombre de correspondances, transporteur (OUIGO, TGV INOUI, TER, Intercités…) et **prix** — y compris avec ou sans **carte de réduction**.

Il est développé comme un [Apify Actor](https://apify.com/actors) : vous disposez donc d'un accès **API**, de la **planification** (scheduling), du **monitoring** et des **intégrations** (Zapier, Make, Google Sheets, Slack…) prêts à l'emploi, sans avoir à maintenir votre propre infrastructure de scraping.

Donnez-lui un `from`, un `to`, une `date` et une heure optionnelle, et il renvoie tous les trajets correspondants en JSON propre. Essayez-le directement depuis l'onglet **Input** d'Apify Console ou appelez-le via l'[Apify API](https://docs.apify.com/api/v2).

### Pourquoi utiliser ce scraper ?

- **Surveillance des prix & horaires** — suivez l'évolution des tarifs sur vos trajets habituels (ex. Paris → Modane, Marseille → Paris) et soyez alerté quand le prix baisse.
- **Automatisation de la planification de voyage** — injectez horaires, durées et prix dans votre propre application, bot ou dashboard.
- **Analyse de l'offre ferroviaire** — comparez les offres par jour, heure et transporteur (OUIGO, TGV INOUI, Intercités…), avec ou sans carte de réduction.
- **Fiable à grande échelle** — exécution dans le cloud, sans machine à maintenir, avec des milliers de recherches planifiées.

### Comment utiliser l'Actor sur Apify

1. Ouvrez la page de l'Actor dans [Apify Console](https://console.apify.com/actors) et cliquez sur **Try it** (Essayer).
2. Dans l'onglet **Input**, remplissez la **gare de départ** (`from`), la **gare d'arrivée** (`to`) et la **date de voyage** (`date`).
3. Adaptez si besoin l'**heure de départ** (`time`), les **voyageurs** (`passengers`) et le **nombre maximum de résultats** (`maxResults`).
4. Cliquez sur **Run** et attendez quelques secondes que la recherche se termine.
5. Ouvrez l'onglet **Dataset** pour consulter ou télécharger les trajets en **JSON, HTML, CSV ou Excel**.

Vous pouvez aussi lancer une recherche par API en une seule requête :

```bash
curl "https://api.apify.com/v2/acts/~your-actor/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "from": "Paris",
    "to": "Modane",
    "date": "2026-08-09",
    "time": "08:00",
    "passengers": [
      {
        "age": 19,
        "typology": "YOUNG",
        "discountCards": ["YOUNG_PASS"],
        "hasDisability": false,
        "hasWheelchair": false,
        "withoutSeatAssignment": false,
        "business": "IS_NOT_BUSINESS"
      }
    ],
    "maxResults": 20
  }'
```

### Input — Explication des données d'entrée

Tous les champs sont décrits dans l'onglet **Input** d'Apify Console. Voici le détail de chaque paramètre.

#### Champs principaux

| Champ        | Type    | Description                                              | Défaut  |
| ------------ | ------- | -------------------------------------------------------- | ------- |
| `from`       | string  | Ville ou gare de départ, ex. `Paris`, `Marseille`        | —       |
| `to`         | string  | Ville ou gare d'arrivée, ex. `Modane`, `Lyon`            | —       |
| `date`       | string  | Date de voyage au format `YYYY-MM-DD`                    | —       |
| `time`       | string  | Heure de départ souhaitée au format `HH:MM`              | `08:00` |
| `passengers` | array   | Liste des voyageurs (voir détail ci-dessous)             | 1 adulte |
| `maxResults` | integer | Nombre maximum de trajets retournés (`0` = illimité)     | `20`    |
| `proxyConfiguration` | object  | Configuration du proxy Apify (voir section dédiée) | Résidentiel FR |

> **Remarque :** `from`, `to` et `date` sont **obligatoires**. Les autres champs ont des valeurs par défaut et peuvent être omis.

#### Le tableau `passengers` (voyageurs)

Chaque voyageur est un objet avec les champs suivants :

| Champ                   | Type    | Description                                                        | Valeurs possibles                          | Défaut   |
| ----------------------- | ------- | ------------------------------------------------------------------ | ------------------------------------------ | -------- |
| `age`                   | integer | Âge du voyageur (0-120)                                            | 0 → 120                                    | `30`     |
| `typology`              | string  | Catégorie de voyageur utilisée par SNCF                            | `ADULT`, `YOUNG`, `CHILD`, `SENIOR`, `INFANT` | `ADULT`  |
| `discountCards`         | array   | Cartes de réduction à appliquer (voir section dédiée)              | `YOUNG_PASS`, `TGV_MAX`, `LIBERTE_PASS_FE`, `IDTGVMAX2` | `[]` |
| `hasDisability`         | boolean | Le voyageur est en situation de handicap                           | `true` / `false`                            | `false`  |
| `hasWheelchair`         | boolean | Le voyageur utilise un fauteuil roulant                            | `true` / `false`                            | `false`  |
| `withoutSeatAssignment` | boolean | Voyager sans réservation de place                                  | `true` / `false`                            | `false`  |
| `business`              | string  | Voyage professionnel ou non                                        | `IS_BUSINESS` / `IS_NOT_BUSINESS`           | `IS_NOT_BUSINESS` |

**Signification des `typology` (catégories d'âge SNCF) :**

| Valeur    | Catégorie            | Tranche d'âge |
| --------- | -------------------- | ------------- |
| `INFANT`  | Bébé                 | 0 - 3 ans     |
| `CHILD`   | Enfant               | 4 - 11 ans    |
| `YOUNG`   | Jeune                | 12 - 26 ans   |
| `ADULT`   | Adulte               | 18 - 59 ans   |
| `SENIOR`  | Senior               | 60 ans et +   |

> Astuce : associez toujours une carte de réduction à la **typologie cohérente** (ex. `YOUNG_PASS` avec `typology: "YOUNG"`) pour obtenir des prix réalistes.

#### Les différentes cartes de réduction (`discountCards`)

Le champ `discountCards` accepte les **codes internes** utilisés par l'API SNCF Connect. Chaque code correspond à une carte commerciale SNCF réelle :

| Code (`discountCards`) | Carte réelle              | À qui ?                 | Bénéfice principal |
| ---------------------- | ------------------------- | ----------------------- | ------------------ |
| `YOUNG_PASS`           | **Carte Avantage Jeune**  | Jeunes de 12 à 27 ans   | Jusqu'à **-30 %** sur les TGV INOUI et Intercités, avec prix plafonnés |
| `TGV_MAX`              | **TGV Max**               | Abonnés (formule mensuelle) | Voyages **illimités** en 2nde classe sur une large sélection de TGV INOUI, OUIGO et Intercités |
| `LIBERTE_PASS_FE`      | **Carte Liberté**         | Voyageurs fréquents / professionnels | Tarifs réduits (~ **-34 %** en 2nde classe, **-28 %** en 1ère classe) sans condition de date ni de quota |
| `IDTGVMAX2`            | **TGVmax 2 (IdTGV Max)**  | Jeunes abonnés          | Voyages **illimités** en 2nde classe sur certaines lignes (offre historique de TGVmax) |

Pour chaque carte sélectionnée, l'Actor calcule le prix réduit correspondant, disponible dans la sortie via le champ `priceWithDiscountCardAmount`. Si plusieurs voyageurs avec des cartes différentes sont fournis, chaque profil est transmis tel quel à l'API SNCF Connect.

#### Configuration du proxy (`proxyConfiguration`)

Pour éviter le blocage par les protections anti-bots de SNCF Connect, l'Actor utilise par défaut le **proxy résidentiel français d'Apify**. Vous pouvez configurer ce comportement via le champ `proxyConfiguration` :

| Champ               | Type    | Description                                 | Défaut |
| ------------------- | ------- | ------------------------------------------- | ------ |
| `useApifyProxy`     | boolean | Activer le proxy Apify                      | `true` |
| `apifyProxyGroups`  | array   | Groupes de proxy (ex. `["RESIDENTIAL"]`)    | `["RESIDENTIAL"]` |
| `apifyProxyCountry` | string  | Code pays pour le proxy (ex. `"FR"`)        | `"FR"` |

**Exemple avec proxy actif (par défaut) :**

```json
{
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "FR"
  }
}
```

**Exemple sans proxy (usage local uniquement) :**

```json
{
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

> ⚠️ **Attention :** désactiver le proxy (`useApifyProxy: false`) peut entraîner un blocage par les protections anti-bots de SNCF Connect, surtout lors d'exécutions répétées depuis la même IP. Cette option est recommandée **uniquement pour les tests locaux** ou si vous utilisez votre propre solution proxy.

### Output — Données de sortie

Chaque trajet est stocké comme un élément du dataset. Les données extraites sont **plus riches que de simples horaires** : l'Actor conserve la **timeline complète** du voyage (`globalTimeline`) avec ses étapes d'**embarquement**, de **train** et de **correspondance**, les **services à bord**, le détail des **offres tarifaires** (1ère / 2nde classe) et l'**état de réservation**.

Exemple réel (trajet Paris → Modane avec 2 correspondances et prix) :

```json
{
    "journeyId": "e9391411-f6b2-430f-bb63-e3156377f5e2, 5c84fc6a-a6b0-469e-9d44-71a75474fd8f, 8f684b88-b8d5-497a-a678-b2fbdb6b7688",
    "from": "Paris - Gare De Lyon - Hall 1 & 2",
    "to": "Modane",
    "origin": {
        "id": "CITY_FR_6455259",
        "label": "Paris",
        "city": "Paris",
        "codes": [{ "type": "RESARAIL", "value": "FRPAR" }]
    },
    "destination": {
        "id": "RESARAIL_STA_8774200",
        "label": "Modane",
        "codes": [
            { "type": "RESARAIL", "value": "FRAGR" },
            { "type": "UIC7", "value": "8774200" },
            { "type": "UIC8", "value": "87742007" }
        ]
    },
    "departure": "2026-08-09T15:14:00+02:00",
    "arrival": "2026-08-09T20:56:00+02:00",
    "departureTime": "15:14",
    "arrivalTime": "20:56",
    "durationLabel": "5h42",
    "transfers": 2,
    "transporter": "2 correspondances",
    "priceAmount": 94,
    "priceCurrency": "EUR",
    "priceLabel": "94,70 €",
    "priceWithDiscountCardAmount": null,
    "firstClassPriceAmount": 116,
    "secondClassPriceAmount": 94,
    "status": { "isBookable": true },
    "globalTimeline": {
        "steps": [
            {
                "onBoarding": {
                    "onBoardingLabel": "Accueil embarquement jusqu'à 2 min avant le départ",
                    "onBoardingTimeLabel": "15:12",
                    "onBoardingTimeImpactedByDisruptionLabel": ""
                }
            },
            {
                "train": {
                    "departure": {
                        "stationCode": "",
                        "stationLabel": "Paris - Gare De Lyon - Hall 1 & 2",
                        "isStationLinkDisplayed": false,
                        "timeLabel": "15:14"
                    },
                    "arrival": {
                        "stationCode": "",
                        "stationLabel": "Grenoble",
                        "isStationLinkDisplayed": false,
                        "timeLabel": "18:13"
                    },
                    "duration": {
                        "label": "2h59",
                        "labelImpactedByDisruption": ""
                    },
                    "transporter": {
                        "modeIcon": { "iconGroup": "Transports", "iconName": "train" },
                        "logo": "tgv_inoui",
                        "number": "n° 6919",
                        "referenceLabel": "n° 6919",
                        "description": "TGV INOUI",
                        "semanticDescription": "TGV INOUI"
                    },
                    "onBoardServices": [
                        { "code": "WIFI", "label": "Wifi à bord", "icon": { "iconGroup": "Services", "iconName": "wifi" } },
                        { "code": "VOITURE_BAR", "label": "Voiture bar", "icon": { "iconGroup": "Services", "iconName": "bar" } },
                        { "code": "NURSERIE", "label": "Espace nurserie", "icon": { "iconGroup": "Services", "iconName": "nursery" } },
                        { "code": "HANDICAPE", "label": "Accessible voyageurs handicapés", "icon": { "iconGroup": "Services", "iconName": "accessibility" } }
                    ],
                    "seatAssignments": [],
                    "stops": [],
                    "tripIv": {
                        "disruptions": { "messages": [] },
                        "vehicleDetails": {
                            "screenTitle": "",
                            "request": {
                                "number": "6919",
                                "date": "2026-08-09",
                                "origin": "RESARAIL_STA_8768600",
                                "destination": "RESARAIL_STA_8774700"
                            }
                        },
                        "upcomingTripSeatsWithCoachLabels": []
                    },
                    "states": [],
                    "segmentIcons": []
                }
            },
            {
                "connection": {
                    "correspondanceTimeLabel": "18 min",
                    "correspondanceTimeImpactedByDisruption": "",
                    "correspondanceRoutingSuggestion": {
                        "icon": { "iconGroup": "Mobility", "iconName": "journey" },
                        "title": "Correspondance",
                        "subTitle": "Voir les itinéraires pour changer de gare."
                    }
                }
            },
            {
                "train": {
                    "departure": { "stationCode": "", "stationLabel": "Grenoble", "timeLabel": "18:31" },
                    "arrival": { "stationCode": "", "stationLabel": "Chambery - Challes-Les-Eaux", "timeLabel": "19:18" },
                    "duration": { "label": "47 min" },
                    "transporter": {
                        "logo": "ter",
                        "number": "n° 17584",
                        "operatedBy": "Opéré par SNCF VOYAGEURS 1187",
                        "referenceLabel": "n° 17584",
                        "description": "Train TER"
                    },
                    "onBoardServices": [{ "code": "VELO_PAYANT", "label": "Espace vélo payant", "icon": { "iconGroup": "Services", "iconName": "bike" } }],
                    "seatAssignments": [],
                    "stops": [],
                    "tripIv": {
                        "disruptions": { "messages": [] },
                        "vehicleDetails": {
                            "screenTitle": "",
                            "request": {
                                "number": "17584",
                                "date": "2026-08-09",
                                "origin": "RESARAIL_STA_8774700",
                                "destination": "RESARAIL_STA_8774100"
                            }
                        },
                        "upcomingTripSeatsWithCoachLabels": []
                    },
                    "states": [],
                    "segmentIcons": []
                }
            }
        ]
    },
    "secondComfortClassOffers": {
        "offers": [],
        "bestPriceLabelPrefix": "dès"
    },
    "legs": [
        {
            "line": "TGV INOUI",
            "trainNumber": "6919",
            "from": "Paris - Gare De Lyon - Hall 1 & 2",
            "to": "Grenoble",
            "departure": "2026-08-09T15:14:00+02:00",
            "arrival": "2026-08-09T18:13:00+02:00",
            "departureTime": "15:14",
            "arrivalTime": "18:13",
            "durationLabel": "2h59"
        },
        {
            "line": "Train TER",
            "trainNumber": "17584",
            "from": "Grenoble",
            "to": "Chambery - Challes-Les-Eaux",
            "departure": "2026-08-09T18:31:00+02:00",
            "arrival": "2026-08-09T19:18:00+02:00",
            "departureTime": "18:31",
            "arrivalTime": "19:18",
            "durationLabel": "47 min"
        }
    ]
}
```

> **Trajet complet / non réservable :** quand un train affiche complet, `status` devient un objet détaillé (ex. `{ "isBookable": false, "label": "Complet", "title": "Complet", "description": "Toutes les places ont déjà été vendues…", "severity": "ALERT" }`) et les prix (`priceAmount`, `priceLabel`, etc.) sont `null`.

Vous pouvez télécharger le dataset dans divers formats : **JSON, HTML, CSV ou Excel**.

### Tableau des données de sortie

| Champ                         | Type    | Description                                                          |
| ----------------------------- | ------- | -------------------------------------------------------------------- |
| `journeyId`                   | string  | ID(s) du trajet ; plusieurs UUID séparés par des virgules si le trajet a plusieurs tronçons |
| `from` / `to`                 | string  | Gare de départ / d'arrivée                                           |
| `origin` / `destination`      | object  | Lieu recherché (`id`, `label`, `city`, `codes`)                      |
| `departure` / `arrival`       | string  | Date-heure ISO 8601 de départ / arrivée                              |
| `departureTime` / `arrivalTime` | string | Heures au format `HH:MM`, ex. `06:46`                               |
| `durationLabel`               | string  | Durée lisible, ex. `4h00`, `5h42`                                    |
| `transfers`                   | integer | Nombre de correspondances                                            |
| `transporter`                 | string  | ex. `Direct TGV INOUI`, `2 correspondances`                          |
| `priceAmount`                 | number  | Prix le plus bas arrondi, ex. `94`                                   |
| `priceCurrency`               | string  | Code devise, ex. `EUR`                                               |
| `priceLabel`                  | string  | Prix formaté (format français), ex. `94,70 €`                        |
| `priceWithDiscountCardAmount` | number  | Prix avec carte de réduction (peut être `null`)                      |
| `firstClassPriceAmount`       | number  | Prix 1ère classe (peut être `null`)                                  |
| `secondClassPriceAmount`      | number  | Prix 2nde classe (peut être `null`)                                  |
| `status`                      | object  | État de réservation : `{ isBookable: true }` ou détail complet (label, description, severity) |
| `globalTimeline`              | object  | Timeline complète : étapes `onBoarding`, `train` et `connection` (voir ci-dessous) |
| `firstComfortClassOffers`     | object  | Bloc d'offres 1ère classe (`offers`, `bestPriceLabel`, `bestPriceLabelPrefix`) |
| `secondComfortClassOffers`    | object  | Bloc d'offres 2nde classe (`offers`, `bestPriceLabel`, `bestPriceLabelPrefix`) |
| `legs`                        | array   | Tronçons de train simplifiés : `line`, `trainNumber`, `from`, `to`, horaires, durée |

#### Détail de la timeline (`globalTimeline.steps`)

Chaque étape de la timeline est l'un des trois types d'objet suivant :

| Type d'étape  | Champs principaux                                                                                          |
| ------------- | ---------------------------------------------------------------------------------------------------------- |
| `onBoarding`  | `onBoardingLabel`, `onBoardingTimeLabel`, `onBoardingTimeImpactedByDisruptionLabel`                        |
| `train`       | `departure` / `arrival` (gare + heure), `duration`, `transporter` (logo, n°, description, opérateur), `onBoardServices` (WIFI, voiture bar…), `seatAssignments`, `stops`, `tripIv` (perturbations, détails du véhicule) |
| `connection`  | `correspondanceTimeLabel`, `correspondanceTimeImpactedByDisruption`, `correspondanceRoutingSuggestion`      |

### Tarification / Estimation du coût

Combien coûte le scraping de SNCF Connect ? Une recherche de trajet est une exécution de navigateur **légère** qui se termine généralement en **moins d'une minute**, pour un coût **bien inférieur à 1 compute unit** par exécution. Avec l'offre gratuite d'Apify, votre quota mensuel de compute units et de stockage couvre des centaines de recherches. Pour un suivi régulier des prix, planifiez l'Actor à l'heure ou par jour : le coût par exécution reste minuscule et prévisible.

### Conseils / Options avancées

- **Limitez les résultats** avec `maxResults` pour accélérer les exécutions si vous n'avez besoin que des premiers départs.
- **Cherchez tôt** — SNCF Connect affiche généralement les meilleurs tarifs pour les dates lointaines ; les horaires se rafraîchissent en cours de journée.
- **Testez les cartes** — comparez le prix avec et sans carte de réduction (`priceWithDiscountCardAmount` vs `priceAmount`) pour identifier le meilleur profil d'achat.
- **Scalez raisonnablement** — SNCF Connect est une plateforme de réservation en direct : gardez `maxResults` bas et évitez un grand nombre de recherches parallèles dans un court laps de temps.
- **Intégrez** — connectez le dataset de sortie à Google Sheets ou Slack via les [intégrations Apify](https://apify.com/integrations) pour des alertes de prix automatiques.

### FAQ, avertissements et support

**Est-ce légal ?** L'Actor ne lit que des informations publiquement visibles sur SNCF Connect. Merci de consulter les Conditions Générales de Vente et le `robots.txt` de SNCF Connect avant toute utilisation commerciale des données, et de toujours respecter les limites de débit. Cet Actor est un projet indépendant, non affilié à la SNCF et non approuvé par elle.

**Limites connues :** SNCF Connect est une application JavaScript lourde avec protections anti-bot — les résultats peuvent changer si la plateforme met à jour son frontend. Certains prix (ex. avec carte de réduction) peuvent être `null` lorsqu'ils ne sont pas proposés pour un trajet donné. Les cartes de réduction ne sont prises en compte que si elles sont compatibles avec la typologie et l'âge du voyageur.

**Retours :** vous avez trouvé un bug ou souhaitez une fonctionnalité personnalisée ? Ouvrez une issue dans l'onglet **Issues** de ce dépôt, ou contactez-nous pour une solution sur mesure.

# Actor input Schema

## `from` (type: `string`):

Departure city or station, e.g. Marseille

## `to` (type: `string`):

Arrival city or station, e.g. Paris

## `date` (type: `string`):

Travel date in YYYY-MM-DD format

## `time` (type: `string`):

Desired departure time in HH:MM format

## `passengers` (type: `array`):

List of passengers (age, typology, discount cards, preferences). Each item matches the PassengerInput type.

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

Maximum number of journeys to return (0 = unlimited)

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

Proxy settings for anti-bot protection. Use Apify Residential proxy (FR) for reliable scraping of SNCF Connect.

## Actor input object example

```json
{
  "from": "Marseille",
  "to": "Paris",
  "date": "2026-06-15",
  "time": "08:00",
  "passengers": [
    {
      "age": 30,
      "hasDisability": false,
      "hasWheelchair": false,
      "typology": "ADULT",
      "discountCards": [],
      "withoutSeatAssignment": false,
      "business": "IS_NOT_BUSINESS"
    }
  ],
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "FR"
  }
}
```

# Actor output Schema

## `journeys` (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 = {
    "from": "Marseille",
    "to": "Paris",
    "date": "2026-06-15",
    "time": "08:00",
    "passengers": [
        {
            "age": 30,
            "hasDisability": false,
            "hasWheelchair": false,
            "typology": "ADULT",
            "discountCards": [],
            "withoutSeatAssignment": false,
            "business": "IS_NOT_BUSINESS"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "FR"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("flo.cl25spt/apify-sncfconnector").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 = {
    "from": "Marseille",
    "to": "Paris",
    "date": "2026-06-15",
    "time": "08:00",
    "passengers": [{
            "age": 30,
            "hasDisability": False,
            "hasWheelchair": False,
            "typology": "ADULT",
            "discountCards": [],
            "withoutSeatAssignment": False,
            "business": "IS_NOT_BUSINESS",
        }],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "FR",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("flo.cl25spt/apify-sncfconnector").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 '{
  "from": "Marseille",
  "to": "Paris",
  "date": "2026-06-15",
  "time": "08:00",
  "passengers": [
    {
      "age": 30,
      "hasDisability": false,
      "hasWheelchair": false,
      "typology": "ADULT",
      "discountCards": [],
      "withoutSeatAssignment": false,
      "business": "IS_NOT_BUSINESS"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "FR"
  }
}' |
apify call flo.cl25spt/apify-sncfconnector --silent --output-dataset

```

## MCP server setup

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

```

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/EkPDFhf8ZsnMe4K6z/builds/Vj0LV9OGUsuDDQape/openapi.json