> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.tangerine365.com/llms.txt.
> For full documentation content, see https://docs.tangerine365.com/llms-full.txt.

# App Banners

POST https://localhost:8090//api/app/banners
Content-Type: application/x-www-form-urlencoded

Retrieves a list of app banners for display in the application.

This endpoint returns banner details such as title, image URL, path, link, and active status.

It may support filtering by platform (iOS/Android/Web) or user segment.

Use this endpoint to populate banners on the home screen or promotional sections of the app.

Reference: https://docs.tangerine365.com/tangerine-365-enterprise/app-banners

## OpenAPI Specification

```yaml
openapi: 3.1.0
info:
  title: Tangerine365 Enterprise
  version: 1.0.0
paths:
  //api/app/banners:
    post:
      operationId: app-banners
      summary: App Banners
      description: >-
        Retrieves a list of app banners for display in the application.


        This endpoint returns banner details such as title, image URL, path,
        link, and active status.


        It may support filtering by platform (iOS/Android/Web) or user segment.


        Use this endpoint to populate banners on the home screen or promotional
        sections of the app.
      tags:
        - ''
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/App Banners_Response_200'
      requestBody:
        content:
          application/json:
            schema:
              type: object
              properties: {}
servers:
  - url: https://localhost:8090
components:
  schemas:
    ApiAppBannersPostResponsesContentApplicationJsonSchemaDataItems:
      type: object
      properties:
        id:
          type: string
        link:
          type: string
        title:
          type: string
        status:
          type: string
        banner_url:
          type: string
          format: uri
        created_at:
          type: string
        image_path:
          type: string
        updated_at:
          type: string
      required:
        - id
        - link
        - title
        - status
        - banner_url
        - created_at
        - image_path
        - updated_at
      title: ApiAppBannersPostResponsesContentApplicationJsonSchemaDataItems
    App Banners_Response_200:
      type: object
      properties:
        data:
          type: array
          items:
            $ref: >-
              #/components/schemas/ApiAppBannersPostResponsesContentApplicationJsonSchemaDataItems
        message:
          type: string
        success:
          type: boolean
      required:
        - data
        - message
        - success
      title: App Banners_Response_200

```

## SDK Code Examples

```python App Banners_example
import requests

url = "https://localhost:8090//api/app/banners"

payload = ""
headers = {"Content-Type": "application/x-www-form-urlencoded"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())
```

```javascript App Banners_example
const url = 'https://localhost:8090//api/app/banners';
const options = {
  method: 'POST',
  headers: {'Content-Type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams('')
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go App Banners_example
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://localhost:8090//api/app/banners"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("Content-Type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby App Banners_example
require 'uri'
require 'net/http'

url = URI("https://localhost:8090//api/app/banners")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Content-Type"] = 'application/x-www-form-urlencoded'

response = http.request(request)
puts response.read_body
```

```java App Banners_example
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://localhost:8090//api/app/banners")
  .header("Content-Type", "application/x-www-form-urlencoded")
  .asString();
```

```php App Banners_example
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://localhost:8090//api/app/banners', [
  'form_params' => null,
  'headers' => [
    'Content-Type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();
```

```csharp App Banners_example
using RestSharp;

var client = new RestClient("https://localhost:8090//api/app/banners");
var request = new RestRequest(Method.POST);
request.AddHeader("Content-Type", "application/x-www-form-urlencoded");
IRestResponse response = client.Execute(request);
```

```swift App Banners_example
import Foundation

let headers = ["Content-Type": "application/x-www-form-urlencoded"]

let request = NSMutableURLRequest(url: NSURL(string: "https://localhost:8090//api/app/banners")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```