# Initialize screen view

- Operation ID: `create-new-screen-view`
- HTTP method: `POST`
- Path: `/schema-service/v2/screen-views/createNew`
- [Human-readable API reference](https://hub.synerise.com/api-reference/asset-management#operation/create-new-screen-view)

## Self-contained OpenAPI method

The fenced document below contains this method's documentation and all of its local references. It is self-contained; no category or master specification fetch is required.

````yaml
openapi: 3.0.0
info:
  title: Synerise Public API
  version: 1.9.5
paths:
  /schema-service/v2/screen-views/createNew:
    post:
      tags:
        - Screen views
      summary: Initialize screen view
      description: |
        Create a screen view. It is created as a blank, without any conditions.

        ---

        **API consumers:** <a href="/api-reference/authorization?tag=Authorization&amp;operationId=profileLogin" target="_blank" rel="noopener">Workspace (Business Profile)</a>, <a href="/api-reference/authorization?tag=Authorization&amp;operationId=userLogin" target="_blank" rel="noopener">Synerise User</a>

        **API key permission required:** `SCHEMA_SERVICE_SCHEMA_CREATE`

        **User role permission required:** `assets_docs: create`
      operationId: create-new-screen-view
      security:
        - JWT: []
        - BasicAuth: []
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              properties:
                name:
                  type: string
                  description: If no name is provided, defaults to "Unnamed document" or Screen View Campaign" (depending on what you are initializing).
                directory:
                  type: string
                  format: uuid
                  description: If no directory is provided, the default directory is used.
      responses:
        "200":
          description: Success
          content:
            application/json:
              schema:
                type: object
                required:
                  - id
                  - businessProfileId
                  - name
                  - status
                  - priority
                  - scheduled
                  - author
                  - content
                  - audience
                  - createdAt
                  - updatedAt
                  - directory
                  - feed
                properties:
                  id:
                    type: string
                    format: uuid
                    description: UUID of the screen view
                  businessProfileId:
                    type: integer
                    description: ID of the workspace where this screen view is saved
                  name:
                    type: string
                    description: Name of the screen view
                  description:
                    type: string
                    description: Description of the screen view
                  status:
                    type: string
                    enum:
                      - DRAFT
                      - ACTIVE
                      - SCHEDULED
                      - PAUSED
                      - FINISHED
                    description: |
                      Status of the screen view

                      - DRAFT: a screen view that is a work in progress, not complete for activation
                      - ACTIVE: a screen view that can be displayed to customers
                      - SCHEDULED: a screen view scheduled to activate later
                      - PAUSED: a screen view that is temporarily stopped and cannot be displayed
                      - FINISHED: a screen view that is stopped and cannot be displayed
                  priority:
                    type: integer
                    description: Priority determines which screen view to show to a customer if their profile matches the conditions of more than one screen view. `1` is the highest priority.
                    default: 99
                  scheduled:
                    type: boolean
                    description: Informs if the screen view has a defined schedule. Screen views scheduled to be published immediately after activation are considered to be scheduled, so only a draft screen view can have this property at `false`. Copied screen views inherit the schedule of their source.
                  author:
                    type: object
                    description: Information about the user who created this screen view
                    required:
                      - id
                    properties:
                      id:
                        type: integer
                        description: ID of the user
                      name:
                        type: string
                        description: Name of the user
                      avatar:
                        type: string
                        description: URL of the author's avatar image
                  content:
                    type: object
                    title: With document groups
                    description: Content of the screen view
                    required:
                      - json
                      - documents
                      - groups
                    properties:
                      json:
                        type: object
                        description: |
                          JSON structure of the screen view. By default, a newly created screen view has the following `json` value:

                          ```
                          "collection": "{% screenviewcollection %}"
                          ```
                          The `{% screenviewcollection %}` insert is used to pick and display the documents from the documents in `documents` or `groups`.

                          If this insert is not used, you must manually insert each document with `{% document slug%}`.
                        additionalProperties:
                          description: Any JSON entity or entities
                      documents:
                        type: array
                        description: An array of [documents](https://help.synerise.com/docs/assets/documents/introduction-to-documents/). If `groups` is used, this array must be empty.
                        items:
                          type: string
                      data:
                        type: array
                        description: An array of documents or Brickworks records
                        items:
                          oneOf:
                            - type: object
                              required:
                                - slug
                              properties:
                                slug:
                                  type: string
                                  description: Slug of the document
                                  example: basket
                                  pattern: "[a-z0-9]+(?:-[a-z0-9]+)*"
                            - type: object
                              description: Object represents brickworks record id.
                              required:
                                - schemaId
                                - objectId
                              properties:
                                schemaId:
                                  type: string
                                  format: uuid
                                objectId:
                                  type: string
                      groups:
                        type: array
                        description: An array of [document groups](https://help.synerise.com/docs/assets/documents/introduction-to-documents/), If `documents` is used, this array must be empty.
                        items:
                          type: string
                          format: uuid
                          example: 43c97b25-4a10-45d0-99b7-d472eea2bb24
                          description: UUID of the group
                      groupsOrder:
                        type: boolean
                        default: false
                        description: By default, group are ordered for display by their priority. When this field is set to `true`, they are displayed according to their order in the `groups` array instead.
                  audience:
                    type: object
                    description: The profiles (clients) which have access to this resource
                    required:
                      - targetType
                    properties:
                      targetType:
                        type: string
                        description: |
                          The method of defining the audience:
                          - SEGMENT sets the audience to segmentations whose UUIDs are provided in `segments`
                          - QUERY sets the audience to an analytics query provided in `query`
                          - ALL sets the audience to all profiles in the database
                        enum:
                          - SEGMENT
                          - QUERY
                          - ALL
                      segments:
                        type: array
                        description: "An array of segmentation IDs. Used with `targetType: SEGMENT`"
                        items:
                          type: string
                      query:
                        type: string
                        description: "Stringified `analysis` object for the segmentation analytics engine. Used with `targetType: QUERY`. Refer to the [Analytics API Reference](https://developers.synerise.com/#operation/addSegmentationPOST_v2)."
                        example: '{"analysis":{"title":"Unnamed segmentation","description":"","unique":true,"segments":[{"title":"Segmentation A","description":"","filter":{"matching":true,"expressions":[{"_id":"a9b76c8e-34bd-4ac3-be8f-f37041d126bd","name":"","type":"FUNNEL","matching":true,"funnel":{"_id":"5c759d73-49c6-409f-96a3-b569dff8f8ff","title":"Unnamed","completedWithin":null,"dateFilter":{"type":"RELATIVE","offset":{"type":"DAYS","value":0},"duration":{"type":"DAYS","value":30}},"steps":[{"_id":"78b97ae0-1bc5-45fb-82a4-4f1280cfbdff","title":"","action":{"id":944,"name":"page.visit"},"eventName":"page.visit","expressions":[]}],"exact":false}}]}}]}}'
                  createdAt:
                    type: string
                    description: Creation date
                    format: date-time
                  updatedAt:
                    type: string
                    format: date-time
                    description: Last update time
                  deletedAt:
                    type: string
                    format: date-time
                    description: Deletion time, if applicable
                    nullable: true
                  directory:
                    type: object
                    description: Details of the directory where the resource is assigned
                    required:
                      - id
                      - name
                      - createdAt
                      - default
                    properties:
                      id:
                        type: string
                        format: uuid
                        description: |
                          UUID of a directory. Directories can be used to organize documents and screen views for display in the Synerise Web Application.
                          - If you want to organize documents for screen view campaigns, use document groups instead.
                          - If you want to organize screen views for display, use screen view feeds instead.
                      name:
                        type: string
                        description: Name of the directory
                      createdAt:
                        type: string
                        format: date-time
                        description: Date and time when the directory was created
                      default:
                        type: boolean
                        description: "`true` if this is the default directory"
                  feed:
                    type: object
                    description: Feeds are used to group screen views, similar to document groups.
                    required:
                      - id
                      - slug
                      - name
                      - createdAt
                      - default
                    properties:
                      id:
                        type: string
                        format: uuid
                        description: UUID of the screen view feed
                      slug:
                        type: string
                        description: Unique slug of the screen view feed
                      name:
                        type: string
                        description: Name of the screen view feed
                      createdAt:
                        type: string
                        description: Creation date
                        format: date-time
                      default:
                        type: boolean
                        description: Informs if this is the default screen view feed
        "400":
          description: See error message for details
          content:
            application/json:
              schema:
                type: object
                properties:
                  timestamp:
                    type: string
                    format: date-time
                    description: Time when the error occurred
                  errorCode:
                    type: string
                    description: |
                      Code of the error, needed for troubleshooting

                      See error reference: [https://developers.synerise.com/errors.html](https://developers.synerise.com/errors.html)
                  status:
                    type: integer
                    description: Error's HTTP status code
                  message:
                    type: string
                    description: Description of the problem
        "401":
          description: "Unauthorized: wrong consumer scope; token missing/expired/invalid; invalid API key; etc."
          content:
            application/json:
              schema:
                type: object
                properties:
                  timestamp:
                    type: string
                    description: Time when the error occurred
                  error:
                    type: string
                    description: Summary of the error
                  message:
                    type: string
                    description: Description of the problem
                  status:
                    type: integer
                    format: int32
                    description: HTTP status code
        "403":
          description: Forbidden; insufficient permissions
          content:
            application/json:
              schema:
                type: object
                properties:
                  timestamp:
                    type: string
                    description: Time when the error occurred
                  error:
                    type: string
                    description: Summary of the error
                  message:
                    type: string
                    description: Description of the problem
                  status:
                    type: integer
                    format: int32
                    description: HTTP status code
        "404":
          description: Resource not found
          content:
            application/json:
              schema:
                type: object
                properties:
                  timestamp:
                    type: string
                    format: date-time
                    description: Time when the error occurred
                  errorCode:
                    type: string
                    description: |
                      Code of the error, needed for troubleshooting

                      See error reference: [https://developers.synerise.com/errors.html](https://developers.synerise.com/errors.html)
                  status:
                    type: integer
                    description: Error's HTTP status code
                  message:
                    type: string
                    description: Description of the problem
        "500":
          description: See error message for details
          content:
            application/json:
              schema:
                type: object
                properties:
                  timestamp:
                    type: string
                    format: date-time
                    description: Time when the error occurred
                  errorCode:
                    type: string
                    description: |
                      Code of the error, needed for troubleshooting

                      See error reference: [https://developers.synerise.com/errors.html](https://developers.synerise.com/errors.html)
                  status:
                    type: integer
                    description: Error's HTTP status code
                  message:
                    type: string
                    description: Description of the problem
      x-snr-doc-urls:
        - /api-reference/loyalty-and-engagement#tag/Screen-views/operation/create-new-screen-view
      x-codeSamples:
        - lang: cURL
          label: cURL
          source: |-
            curl --request POST \
              --url https://api.synerise.com/schema-service/v2/screen-views/createNew \
              --header 'Authorization: Basic REPLACE_BASIC_AUTH' \
              --header 'content-type: application/json' \
              --data '{"name":"string","directory":"5277859d-f92c-478c-acab-7680a97fea68"}'
        - lang: Python
          label: Python
          source: |-
            import http.client

            conn = http.client.HTTPSConnection("api.synerise.com")

            payload = "{\"name\":\"string\",\"directory\":\"5277859d-f92c-478c-acab-7680a97fea68\"}"

            headers = {
                'Authorization': "Basic REPLACE_BASIC_AUTH",
                'content-type': "application/json"
                }

            conn.request("POST", "/schema-service/v2/screen-views/createNew", payload, headers)

            res = conn.getresponse()
            data = res.read()

            print(data.decode("utf-8"))
        - lang: JavaScript
          label: JavaScript
          source: |-
            const data = JSON.stringify({
              "name": "string",
              "directory": "5277859d-f92c-478c-acab-7680a97fea68"
            });

            const xhr = new XMLHttpRequest();
            xhr.withCredentials = true;

            xhr.addEventListener("readystatechange", function () {
              if (this.readyState === this.DONE) {
                console.log(this.responseText);
              }
            });

            xhr.open("POST", "https://api.synerise.com/schema-service/v2/screen-views/createNew");
            xhr.setRequestHeader("Authorization", "Basic REPLACE_BASIC_AUTH");
            xhr.setRequestHeader("content-type", "application/json");

            xhr.send(data);
        - lang: Node.js
          label: Node.js
          source: |-
            const http = require("https");

            const options = {
              "method": "POST",
              "hostname": "api.synerise.com",
              "port": null,
              "path": "/schema-service/v2/screen-views/createNew",
              "headers": {
                "Authorization": "Basic REPLACE_BASIC_AUTH",
                "content-type": "application/json"
              }
            };

            const req = http.request(options, function (res) {
              const chunks = [];

              res.on("data", function (chunk) {
                chunks.push(chunk);
              });

              res.on("end", function () {
                const body = Buffer.concat(chunks);
                console.log(body.toString());
              });
            });

            req.write(JSON.stringify({name: 'string', directory: '5277859d-f92c-478c-acab-7680a97fea68'}));
            req.end();
        - lang: PHP
          label: PHP
          source: |-
            <?php

            $request = new HttpRequest();
            $request->setUrl('https://api.synerise.com/schema-service/v2/screen-views/createNew');
            $request->setMethod(HTTP_METH_POST);

            $request->setHeaders([
              'Authorization' => 'Basic REPLACE_BASIC_AUTH',
              'content-type' => 'application/json'
            ]);

            $request->setBody('{"name":"string","directory":"5277859d-f92c-478c-acab-7680a97fea68"}');

            try {
              $response = $request->send();

              echo $response->getBody();
            } catch (HttpException $ex) {
              echo $ex;
            }
        - lang: Java
          label: Java
          source: |-
            HttpResponse<String> response = Unirest.post("https://api.synerise.com/schema-service/v2/screen-views/createNew")
              .header("Authorization", "Basic REPLACE_BASIC_AUTH")
              .header("content-type", "application/json")
              .body("{\"name\":\"string\",\"directory\":\"5277859d-f92c-478c-acab-7680a97fea68\"}")
              .asString();
servers:
  - url: https://api.synerise.com
    description: Microsoft Azure EU
  - url: https://api.azu.synerise.com
    description: Microsoft Azure USA
  - url: https://api.geb.synerise.com
    description: Google Cloud Platform
tags:
  - name: Screen views
components:
  securitySchemes:
    JWT:
      type: http
      scheme: bearer
      description: |
        Synerise uses [JSON Web Token (JWT)](https://jwt.io/) as the authorization method.

        The token is generated by the *auth/login* endpoints.

        You need to include it in the `Authorization` header of your requests, with a `Bearer` prefix.


        By default, the token is valid for **one week** (see [workspace settings](https://hub.synerise.com/docs/settings/tool/iam-for-apps/general/#jwt-lifetime)).  
        You can request a refreshed key for the session by using the *auth/refresh* endpoint **before** the current token expires.


        You can verify your JWT signature by using the [public key](https://api.synerise.com/v4/public.pem).


        See Developer Guides on JWT API authentication for:
        - [profiles](https://hub.synerise.com/developers/api/api-authorization/client-login/);
        - [workspaces](https://hub.synerise.com/developers/api/api-authorization/workspace-login/#api-authentication-with-jwt);
        - [users](https://hub.synerise.com/developers/api/api-authorization/user-login/).
    BasicAuth:
      type: http
      scheme: basic
      description: |
        Basic authentication with login (workspace GUID) and password (workspace API key) encoded with Base64 and sent in the `Authorization` header. **Must be enabled in the settings of the API key**.

        <span style="color:red">This is less secure than JWTs.</span> Limit the API key permissions to only those that you need. Consider API key rotation and other security measures.

        You can still use JWTs from the same API key when basic authentication is enabled.

        For details, see ["Workspace authentication"](https://hub.synerise.com/jwt-or-basic/#basic-api-authentication-with-api-keys).
````
