> ## Documentation Index > Fetch the complete documentation index at: https://documentation.onesignal.com/llms.txt > Use this file to discover all available pages before exploring further. # View journeys > Retrieve a paginated list of journeys for an app, with cursor-based pagination and a lightweight summary representation of each journey. **Beta.** The Journeys API is in beta. Endpoints and response fields can still change. ## Overview Retrieve a list of [Journeys](/docs/en/journeys-overview) for an app. Each journey is returned in a summary representation that includes identity, state, scheduling, and re-entry fields, plus the audience `kind`. Use this list to find a journey `id`. Then fetch [View journey](/reference/view-journey) for the full audience, nodes, and the `concurrency_key` required to update it. *** ## How to use this API Authenticate with your [App API Key](/docs/en/keys-and-ids). The authenticated key must have permission to view journeys. ### Pagination This endpoint uses forward-only, cursor-based pagination. Journeys are returned newest first. * Omit `cursor` on the first request. * Set `limit` to control page size. The default is `50` and the maximum is `50`. * When more results exist, the response includes `has_more: true` and a `next_cursor` token. Pass that token as the `cursor` parameter on the next request. `cursor` is opaque: send a prior `next_cursor` unchanged. Do not construct it. * `next_cursor` is omitted once there are no more pages. ```http theme={null} GET /apps/{app_id}/journeys?limit=50&cursor=NTA= ``` ### Response | Field | Type | Description | | ------------- | ------- | ----------------------------------------------------------------- | | `journeys` | array | Summary objects, newest first. | | `has_more` | boolean | `true` when more journeys exist beyond this page. | | `next_cursor` | string | Cursor for the next page. Present only when `has_more` is `true`. | Each journey in the list excludes `description`, `nodes`, `early_exit`, and `concurrency_key`, and includes only the `kind` of its `audience`. Use [View journey](/reference/view-journey) to retrieve the full audience, node configuration, and `concurrency_key`. ### Error responses | Status | Code | Description | | ------ | ---------------------- | --------------------------------------------------------------------------------------------------------------------------------------- | | 400 | `invalid-cursor` | The `cursor` value could not be decoded. | | 403 | `journey-not-entitled` | Journeys are not enabled for this app. | | 429 | | Rate limit exceeded. Wait the number of seconds in the `Retry-After` header before retrying. See [Rate limits](/reference/rate-limits). | Coded errors use the shape `{ "errors": [{ "code", "title", "meta" }] }`. ## OpenAPI ````yaml GET /apps/{app_id}/journeys openapi: 3.1.0 info: title: api.onesignal.com version: '11.6' servers: - url: https://api.onesignal.com security: - {} paths: /apps/{app_id}/journeys: get: summary: View journeys description: >- Retrieve a paginated list of journeys for an app. Returns a summary representation of each journey; use [View journey](/reference/view-journey) for the full configuration. Uses forward-only cursor-based pagination. operationId: view-journeys parameters: - name: app_id in: path description: >- Your OneSignal App ID in UUID v4 format. See [Keys & IDs](/docs/en/keys-and-ids). schema: type: string default: YOUR_APP_ID required: true - name: Authorization in: header description: >- Your App API key with prefix `Key `. See [Keys & IDs](/docs/en/keys-and-ids). required: true schema: type: string default: Key YOUR_APP_API_KEY - name: cursor in: query description: >- Opaque pagination token from a previous response's `next_cursor`. Omit for the first page. schema: type: string - name: limit in: query description: Maximum journeys to return per page. Minimum `1`, maximum `50`. schema: type: integer default: 50 minimum: 1 maximum: 50 responses: '200': description: '200' content: application/json: schema: type: object properties: journeys: type: array items: $ref: '#/components/schemas/JourneyListItem' description: Journeys ordered by creation time, newest first. has_more: type: boolean description: '`true` if more journeys exist beyond this page.' next_cursor: type: string description: >- Cursor for the next page. Present only when `has_more` is `true`. examples: Result: value: journeys: - id: 0a1b2c3d-4e5f-6071-8293-a4b5c6d7e8f9 app_id: 1a2b3c4d-5e6f-7081-92a3-b4c5d6e7f809 name: Welcome series state: active created_at: '2026-06-01T14:00:00Z' updated_at: '2026-06-02T09:30:00Z' started_at: '2026-06-02T09:30:00Z' archived_at: null created_source: public_api schedule: null audience: kind: segment reentry_rules: null has_more: true next_cursor: NTA= '400': description: '400' content: application/json: schema: $ref: '#/components/schemas/JourneyCodedErrorResponse' example: errors: - code: invalid-cursor title: Invalid cursor meta: {} '403': description: '403' content: application/json: schema: $ref: '#/components/schemas/JourneyCodedErrorResponse' example: errors: - code: journey-not-entitled title: Journeys are not enabled for this app meta: {} '429': description: '429' headers: Retry-After: description: >- Number of seconds to wait before retrying the request. Always emitted on 429 responses. schema: type: integer minimum: 0 x-codeSamples: - lang: typescript label: Node.js SDK source: >- import Onesignal from '@onesignal/node-onesignal'; const configuration = Onesignal.createConfiguration({ restApiKey: 'YOUR_REST_API_KEY', }); const apiInstance = new Onesignal.DefaultApi(configuration); // string | Your OneSignal App ID in UUID v4 format. const appId: string = "YOUR_APP_ID"; // string | Opaque pagination token from a previous response\'s next_cursor. Omit for the first page. (optional) const cursor: string = "cursor_example"; // number | Maximum journeys to return per page. Minimum 1, maximum 50. (optional) const limit: number = 50; try { const response = await apiInstance.viewJourneys(appId, cursor, limit); console.log(response); } catch (e) { if (e instanceof Onesignal.ApiException) { // `e.errorMessages` flattens any error-envelope shape to a `string[]`; // the raw parsed body remains on `e.body`. console.error("viewJourneys failed: HTTP " + e.code, e.errorMessages); } else { throw e; } } - lang: python label: Python SDK source: >- import onesignal from onesignal.api import default_api from onesignal.models import * from pprint import pprint # See configuration.py for a list of all supported configuration parameters. # Some of the OneSignal endpoints require ORGANIZATION_API_KEY token for authorization, while others require REST_API_KEY. # We recommend adding both of them in the configuration page so that you will not need to figure it out yourself. configuration = onesignal.Configuration( rest_api_key = "YOUR_REST_API_KEY", # App REST API key required for most endpoints organization_api_key = "YOUR_ORGANIZATION_API_KEY" # Organization key is only required for creating new apps and other top-level endpoints ) # Enter a context with an instance of the API client with onesignal.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = default_api.DefaultApi(api_client) app_id = "YOUR_APP_ID" # Your OneSignal App ID in UUID v4 format. cursor = "cursor_example" # Opaque pagination token from a previous response's next_cursor. Omit for the first page. (optional) limit = 50 # Maximum journeys to return per page. Minimum 1, maximum 50. (optional) try: # View journeys api_response = api_instance.view_journeys(app_id, cursor=cursor, limit=limit) pprint(api_response) except onesignal.ApiException as e: print("Exception when calling DefaultApi->view_journeys: %s\n" % e) print("Status Code: %s" % e.status) print("Response Body: %s" % e.body) - lang: php label: PHP SDK source: >- setRestApiKeyToken('YOUR_REST_API_KEY') ->setOrganizationApiKeyToken('YOUR_ORGANIZATION_API_KEY'); $apiInstance = new onesignal\client\Api\DefaultApi( // If you want use custom http client, pass your client which implements `GuzzleHttp\ClientInterface`. // This is optional, `GuzzleHttp\Client` will be used as default. new GuzzleHttp\Client(), $config ); $app_id = 'YOUR_APP_ID'; // string | Your OneSignal App ID in UUID v4 format. $cursor = 'cursor_example'; // string | Opaque pagination token from a previous response's next_cursor. Omit for the first page. $limit = 50; // int | Maximum journeys to return per page. Minimum 1, maximum 50. try { $result = $apiInstance->viewJourneys($app_id, $cursor, $limit); print_r($result); } catch (\onesignal\client\ApiException $e) { echo 'Exception when calling DefaultApi->viewJourneys: ', $e->getMessage(), PHP_EOL; echo 'Status Code: ', $e->getCode(), PHP_EOL; // getErrorMessages() flattens any error-envelope shape to a string[]; // the raw body remains on getResponseBody(). echo 'Error Messages: ', implode(', ', $e->getErrorMessages()), PHP_EOL; echo 'Response Body: ', $e->getResponseBody(), PHP_EOL; } catch (\Exception $e) { echo 'Exception when calling DefaultApi->viewJourneys: ', $e->getMessage(), PHP_EOL; } - lang: go label: Go SDK source: |- package main import ( "context" "fmt" "os" "github.com/OneSignal/onesignal-go-api/v5" ) func main() { appId := "YOUR_APP_ID" // string | Your OneSignal App ID in UUID v4 format. cursor := "cursor_example" // string | Opaque pagination token from a previous response's next_cursor. Omit for the first page. (optional) limit := int32(50) // int32 | Maximum journeys to return per page. Minimum 1, maximum 50. (optional) (default to 50) configuration := onesignal.NewConfiguration() apiClient := onesignal.NewAPIClient(configuration) restAuth := context.WithValue(context.Background(), onesignal.RestApiKey, "YOUR_REST_API_KEY") // App REST API key required for most endpoints resp, r, err := apiClient.DefaultApi.ViewJourneys(restAuth, appId).Cursor(cursor).Limit(limit).Execute() if err != nil { fmt.Fprintf(os.Stderr, "Error when calling `DefaultApi.ViewJourneys``: %v\n", err) fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r) if apiErr, ok := err.(*onesignal.GenericOpenAPIError); ok { // ErrorMessages() flattens any error-envelope shape to a []string; // the raw body remains on Body(). fmt.Fprintf(os.Stderr, "Error Messages: %v\n", apiErr.ErrorMessages()) fmt.Fprintf(os.Stderr, "Response Body: %s\n", apiErr.Body()) } } // response from `ViewJourneys`: JourneyListResponse fmt.Fprintf(os.Stdout, "Response from `DefaultApi.ViewJourneys`: %v\n", resp) } - lang: ruby label: Ruby SDK source: >- require 'onesignal' # setup authorization OneSignal.configure do |config| # Configure Bearer authorization: rest_api_key config.rest_api_key = 'YOUR_REST_API_KEY' end api_instance = OneSignal::DefaultApi.new app_id = 'YOUR_APP_ID' # String | Your OneSignal App ID in UUID v4 format. opts = { cursor: 'cursor_example', # String | Opaque pagination token from a previous response's next_cursor. Omit for the first page. limit: 50 # Integer | Maximum journeys to return per page. Minimum 1, maximum 50. } begin # View journeys result = api_instance.view_journeys(app_id, opts) p result rescue OneSignal::ApiError => e puts "Error when calling DefaultApi->view_journeys: #{e}" puts "Status Code: #{e.code}" # `e.error_messages` flattens any error-envelope shape to an Array; # the raw body remains on `e.response_body`. puts "Error Messages: #{e.error_messages}" puts "Response Body: #{e.response_body}" end - lang: java label: Java SDK source: |- // Import classes: import com.onesignal.client.ApiClient; import com.onesignal.client.ApiException; import com.onesignal.client.Configuration; import com.onesignal.client.auth.*; import com.onesignal.client.model.*; import com.onesignal.client.api.DefaultApi; public class Example { public static void main(String[] args) { ApiClient defaultClient = Configuration.getDefaultApiClient(); defaultClient.setBasePath("https://api.onesignal.com"); // Configure HTTP bearer authorization: rest_api_key HttpBearerAuth rest_api_key = (HttpBearerAuth) defaultClient.getAuthentication("rest_api_key"); rest_api_key.setBearerToken("YOUR_REST_API_KEY"); DefaultApi apiInstance = new DefaultApi(defaultClient); String appId = "YOUR_APP_ID"; // String | Your OneSignal App ID in UUID v4 format. String cursor = "cursor_example"; // String | Opaque pagination token from a previous response's next_cursor. Omit for the first page. Integer limit = 50; // Integer | Maximum journeys to return per page. Minimum 1, maximum 50. try { JourneyListResponse result = apiInstance.viewJourneys(appId, cursor, limit); System.out.println(result); } catch (ApiException e) { System.err.println("Exception when calling DefaultApi#viewJourneys"); System.err.println("Status code: " + e.getCode()); // getErrorMessages() flattens any error-envelope shape to a List; // the raw body remains on getResponseBody(). System.err.println("Error messages: " + e.getErrorMessages()); System.err.println("Reason: " + e.getResponseBody()); System.err.println("Response headers: " + e.getResponseHeaders()); e.printStackTrace(); } } } - lang: csharp label: C# SDK source: |- using System; using System.Collections.Generic; using System.Diagnostics; using OneSignalApi.Api; using OneSignalApi.Client; using OneSignalApi.Model; namespace Example { public class ViewJourneysExample { public static void Main() { Configuration config = new Configuration(); config.BasePath = "https://api.onesignal.com"; // Configure Bearer token for authorization: rest_api_key config.AccessToken = "YOUR_REST_API_KEY"; var apiInstance = new DefaultApi(config); var appId = "YOUR_APP_ID"; // string | Your OneSignal App ID in UUID v4 format. var cursor = "cursor_example"; // string | Opaque pagination token from a previous response's next_cursor. Omit for the first page. (optional) var limit = 50; // int? | Maximum journeys to return per page. Minimum 1, maximum 50. (optional) (default to 50) try { // View journeys JourneyListResponse result = apiInstance.ViewJourneys(appId, cursor, limit); Debug.WriteLine(result); } catch (ApiException e) { Debug.Print("Exception when calling DefaultApi.ViewJourneys: " + e.Message ); Debug.Print("Status Code: "+ e.ErrorCode); // e.ErrorMessages flattens any error-envelope shape to an IReadOnlyList; // the raw body remains on e.ErrorContent. Debug.Print("Error Messages: " + string.Join(", ", e.ErrorMessages)); Debug.Print("Response Body: " + e.ErrorContent); Debug.Print(e.StackTrace); } } } } - lang: rust label: Rust SDK source: |- use onesignal_rust_api::apis::configuration::Configuration; use onesignal_rust_api::apis::default_api; #[tokio::main] async fn main() { let mut configuration = Configuration::new(); configuration.rest_api_key_token = Some("YOUR_REST_API_KEY".to_string()); // Realistic values are pulled from the spec's `example:` fields where present. let app_id: &str = "YOUR_APP_ID"; let cursor: Option<&str> = None; let limit: Option = None; match default_api::view_journeys(&configuration, app_id, cursor, limit).await { Ok(resp) => println!("{:?}", resp), Err(e @ onesignal_rust_api::apis::Error::ResponseError(_)) => { // `e.error_messages()` flattens any error-envelope shape to a Vec; // the raw response remains on the ResponseError variant. eprintln!("view_journeys failed: {:?}", e.error_messages()); } Err(e) => eprintln!("view_journeys failed: {:?}", e), } } components: schemas: JourneyListItem: type: object description: >- Summary journey representation returned by the list endpoint. Excludes description, nodes, and early-exit configuration, and reduces audience to its kind. properties: id: type: string description: Journey UUID. Read-only. app_id: type: string description: UUID of the app the journey belongs to. Read-only. name: type: string description: Journey name, up to 300 characters. state: type: string enum: - draft - scheduled - processing - active - archived description: >- Journey state. Read-only. New journeys are created as `draft`. `processing` is a transient state while an activation is in progress, and `archived` is a journey that has been stopped. Change it through the `state` field on [Update journey](/reference/update-journey). created_at: type: string description: ISO 8601 creation time. Read-only. updated_at: type: string description: ISO 8601 last-update time. Read-only. started_at: type: - string - 'null' description: >- ISO 8601 time the journey was activated, or `null`. Read-only. May stay `null` briefly after you set `state` to `active`: activation is enqueued for processing, and `started_at` populates once the journey finishes processing and becomes active. archived_at: type: - string - 'null' description: ISO 8601 time the journey was archived, or `null`. Read-only. created_source: type: - string - 'null' description: >- Origin of the journey, for example `public_api` or `dashboard`. Read-only. schedule: $ref: '#/components/schemas/JourneySchedule' audience: type: object description: >- Entry audience reduced to its kind. Use [View journey](/reference/view-journey) for the full audience configuration. properties: kind: type: string enum: - segment - event_trigger description: Audience kind. reentry_rules: $ref: '#/components/schemas/JourneyReentryRules' JourneyCodedErrorResponse: type: object description: Error response with a stable machine-readable `code`. properties: errors: type: array items: type: object properties: code: type: string description: >- Stable, kebab-case error identifier. Does not change once shipped. title: type: string description: Human-readable message. Wording may change between releases. meta: type: object description: Optional structured context. Shape varies by error. JourneySchedule: type: - object - 'null' description: >- Optional future start and/or stop time. `null` means no scheduled activation. properties: start_at: type: - string - 'null' description: >- ISO 8601 start time. Use UTC (`Z` or `+00:00`). Must be at least 5 minutes in the future. stop_at: type: - string - 'null' description: >- ISO 8601 stop time. Use UTC (`Z` or `+00:00`). Must be in the future and later than `start_at`. error: type: - string - 'null' description: Read-only. Present when a scheduling error occurred. JourneyReentryRules: type: - object - 'null' description: >- Controls whether and how soon a user can re-enter the journey. `null` means re-entry is not allowed. properties: duration_seconds: type: integer minimum: 600 description: >- Minimum seconds before a user can re-enter. Must be at least `600` (10 minutes). ````