> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.lettbestilt.no/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.lettbestilt.no/_mcp/server.

# Get the menu

GET https://www.lettbestilt.no/api/v1/menu

Returns everything a menu page and checkout need in one call: the restaurant (branding, capabilities, opening hours, special opening hours, delivery zones and shared add-on groups), the active menus, categories with products, variants, add-ons and allergens, code-based coupons, automatic promotions, the allergen list and upsell products.

**Only what can be ordered now.** `menus` and `categories` contain only the menus that are active when the response is built: the validity period (`startsOn`/`endsOn`) is checked first, then the schedules, and the default menu is the fallback. `upsell.products` is filtered the same way. Products and add-ons the restaurant has hidden or marked unavailable are left out.

**Two sets of opening hours.** `restaurant.openingHours` are the kitchen's hours and the only set that decides whether an order is accepted. Always gate the ordering flow on these. `restaurant.venueHours` are the venue's hours (when the doors are open) and are for display only. An empty `venueHours` means the venue follows the kitchen; show `openingHours` instead.

**Caching.** The response is cached at the edge (30 s, plus 300 s stale-while-revalidate) and carries a weak `ETag`. Send it back in `If-None-Match` to get `304 Not Modified`. Because of the cache, show the preparation time from `GET /prep-time`, not from `restaurant.prepTime`.

**Address.** `restaurant.address` is the visiting address, or `null`: the same object as in `GET /restaurant`. Use it on the contact page and for `address` and `geo` in Restaurant JSON-LD.

**Allergens.** `products[].allergens` are codes. Look them up in the top-level `allergens` list, which always comes in the same order.

Reference: https://docs.lettbestilt.no/api-reference/restaurant-and-menu/get-menu

## Authentication

- `Authorization` header (bearer token, required) — Either this or a trusted browser origin. The restaurant's API key, sent as `Authorization: Bearer lbs_…`. Use it from your server only, never in browser code. Keys are issued per restaurant by LettBestilt.
- `Origin` header (required) — Either this or an API key. No key is needed when the request's `Origin` header is trusted for this restaurant: `https://{slug}.lettbestilt.no`, a verified domain of the restaurant, or a partner origin LettBestilt has bound to the restaurant. Browsers set `Origin` themselves; it is not something you configure. Not accepted by `GET /site-gate`, which requires an API key.

## Request

### Query parameters

- `slug` (string, required) — The restaurant's slug, which is also its LettBestilt subdomain (`{slug}.lettbestilt.no`).

### Headers

- `If-None-Match` (string, optional) — The `ETag` from an earlier response. If the menu has not changed, the response is `304 Not Modified` with no body.

## Response

### 200

The menu, with a weak `ETag` and `Cache-Control` headers.

- `restaurant` (MenuRestaurant, optional)
- `menus` (list of Menu, optional) — Only menus that are active when the response is built (validity period, then schedule, then the default menu as fallback). The response is cached at the edge, so also hide a menu on the client when today's date in Oslo is before `startsOn` or after `endsOn`. A missing field means no limit.
- `categories` (list of ApiV1MenuGetResponsesContentApplicationJsonSchemaCategoriesItems, optional) — Top-level categories on the active menus, with their products.
- `coupons` (list of PublicCoupon, optional) — Code-based coupons, without the code itself. The customer types the code; `POST /coupons/validate` checks it.
- `promotions` (list of PublicCoupon, optional) — Automatic promotions. Show them as banners; the server applies the best match when the order is created.
- `upsell` (ApiV1MenuGetResponsesContentApplicationJsonSchemaUpsell, optional, nullable) — Products the restaurant wants to suggest in the cart, or `null` if upsell is not set up. `mode` tells whether the list is picked by popularity or by hand.

## Errors

### 400 Bad Request Error

`MISSING_SLUG`: the `slug` query parameter is missing.

- `error` (ErrorBody, required)

### 401 Unauthorized Error

`UNAUTHORIZED`: missing or invalid API key, and the request does not come from a trusted browser origin.

- `error` (ErrorBody, required)

### 404 Not Found Error

`RESTAURANT_NOT_FOUND`: no live restaurant has this slug.

- `error` (ErrorBody, required)

## Types

### MenuRestaurant

- `address` (Address, optional, nullable) — The restaurant's public visiting address. Safe to publish: on the contact page, as `address` and `geo` in Restaurant JSON-LD, and as the map point for pickup. The field is `null` when the restaurant has no street address. It is never an empty shell, so `address === null` means "no address to show", not "an address with empty fields". `latitude` and `longitude` are both set or both `null`; check one of them before you render a map.
- `openingHours` (list of DayHours, optional) — The kitchen's opening hours. The only set that gates ordering: the server rejects an order outside these hours.
- `venueHours` (list of DayHours, optional) — The venue's opening hours (when the doors are open). Display only: never use them to decide whether ordering is possible. An empty array means the venue follows the kitchen, so show `openingHours` instead.

### Menu

A menu, such as the main menu or a lunch menu. Only menus that are active right now are returned.

- `id` (string, required)
- `name` (string, required)
- `isDefault` (boolean, required) — The fallback menu, used when no other menu is active.
- `priority` (integer, required) — Decides which menu wins when several are active at the same time.
- `sortOrder` (integer, required)
- `schedules` (list of MenuSchedule, required) — When the menu is active. Empty means it is not limited by time of day.
- `nameEn` (string, optional, nullable)
- `description` (string, optional, nullable)
- `startsOn` (date, optional, nullable) — First valid day (Europe/Oslo), inclusive. `null` means no lower limit.
- `endsOn` (date, optional, nullable) — Last valid day (Europe/Oslo), inclusive. `null` means no upper limit.

### ApiV1MenuGetResponsesContentApplicationJsonSchemaCategoriesItems

- `id` (string, optional)
- `menuId` (string, optional)
- `name` (string, optional)
- `nameEn` (string, optional, nullable)
- `description` (string, optional, nullable)
- `imageUrl` (string, optional, nullable)
- `sortOrder` (integer, optional)
- `addonGroups` (list of AddonGroup, optional)
- `products` (list of Product, optional)

### PublicCoupon

An offer or coupon, as `GET /menu` lists them in `coupons` (code-based) and `promotions` (automatic). The code itself is never included: the customer types it, and `POST /coupons/validate` decides whether it applies.

- `id` (string, required)
- `discountType` (enum, required) — Treat unknown values as a general offer, since more types may be added. `BUNDLE` means "X for Y kr".
  - Allowed values: `PERCENT`, `FIXED`, `FIXED_PRICE`, `FREE_DELIVERY`, `BUNDLE`
- `discountValue` (integer, required) — `PERCENT`: percent. `FIXED` and `FIXED_PRICE`: øre. `BUNDLE`: the price in øre for one bundle of `bundleQuantity` units, not the discount; show `discount` from validate or preview-auto.
- `minimumOrder` (integer, required) — Minimum subtotal in øre.
- `isAutomatic` (boolean, required) — `true` for automatic promotions, `false` for code-based coupons.
- `appliesTo` (enum, required)
  - Allowed values: `ORDER`, `CATEGORIES`, `PRODUCTS`
- `description` (string, optional, nullable)
- `displayName` (string, optional, nullable) — A short name for banners.
- `displayBadge` (string, optional, nullable) — A short badge text, for example "-20%".
- `usageLimit` (integer, optional, nullable)
- `usageCount` (integer, optional)
- `validFrom` (datetime, optional, nullable)
- `validTo` (datetime, optional, nullable)
- `priority` (integer, optional)
- `allowedDaysOfWeek` (list of integer, optional) — 0 = Sunday … 6 = Saturday (Europe/Oslo). An empty list means every day.
- `allowedFulfillment` (enum, optional) — `PICKUP` or `DELIVERY` if the offer is limited to one of them, otherwise `null`.
  - Allowed values: `PICKUP`, `DELIVERY`
- `allowedTimeStart` (string, optional, nullable) — HH:MM, Europe/Oslo.
- `allowedTimeEnd` (string, optional, nullable) — HH:MM, Europe/Oslo.
- `bundleQuantity` (integer, optional, nullable) — `BUNDLE` only: number of units in one bundle. `null` for other types.
- `bundleTierKey` (string, optional, nullable) — `BUNDLE` only: only variants with this `addonTierKey` count (for example "stor"). `null` means all sizes.
- `maxBundlesPerOrder` (integer, optional, nullable) — `BUNDLE` only: maximum bundles per order. `null` means no limit.
- `categories` (list of PublicCouponCategoriesItems, optional) — The categories the offer applies to when `appliesTo` is `CATEGORIES`.
- `products` (list of PublicCouponProductsItems, optional) — The products the offer applies to when `appliesTo` is `PRODUCTS`.

### ApiV1MenuGetResponsesContentApplicationJsonSchemaUpsell

Products the restaurant wants to suggest in the cart, or `null` if upsell is not set up. `mode` tells whether the list is picked by popularity or by hand.

- `isActive` (boolean, optional)
- `mode` (enum, optional)
  - Allowed values: `POPULAR`, `MANUAL`
- `products` (list of ApiV1MenuGetResponsesContentApplicationJsonSchemaUpsellProductsItems, optional) — Only active, available products on menus that are active now. (Before October 2026, products on inactive menus were also returned.)

### ErrorBody

- `code` (enum, required) — A machine-readable error code.
  - Allowed values: `MISSING_SLUG`, `MISSING_TOKEN`, `INVALID_JSON`, `INVALID_SUCCESS_URL`, `INVALID_CANCEL_URL`, `VALIDATION_FAILED`, `RESTAURANT_NOT_FOUND`, `ORDER_NOT_FOUND`, `RATE_LIMITED`, `BAD_REQUEST`, `UNAUTHORIZED`, `FORBIDDEN`, `POPUP_NOT_AVAILABLE`, `PRICE_CHANGED`, `PAYMENT_INCOMPLETE`, `PAYMENT_PENDING`, `PAYMENT_PROVIDER_INVALID`, `FULFILLMENT_NOT_ALLOWED`, `IDEMPOTENCY_CONFLICT`, `DINE_IN_DISABLED`, `PARTY_TOO_LARGE`, `TOO_EARLY`, `INTERNAL_ERROR`
- `message` (string, required) — A human-readable explanation. Often in Norwegian, and for business rules usually suitable to show the customer.
- `details` (any, optional) — Extra data for some codes, for example `issues` for `VALIDATION_FAILED` or the totals for `PRICE_CHANGED`.

### Address

The restaurant's public visiting address. Safe to publish: on the contact page, as `address` and `geo` in Restaurant JSON-LD, and as the map point for pickup. The field is `null` when the restaurant has no street address. It is never an empty shell, so `address === null` means "no address to show", not "an address with empty fields". `latitude` and `longitude` are both set or both `null`; check one of them before you render a map.

- `line1` (string, required) — Street address, for example "Heggeliveien 5". Never empty.
- `postalCode` (string, required, nullable) — Four digits, for example "9325".
- `city` (string, required, nullable) — Postal town, for example "Bardufoss".
- `country` (enum, required) — ISO 3166-1 alpha-2. Always "NO".
  - Allowed values: `NO`
- `latitude` (double, required, nullable) — WGS84. Set when the owner picked the address from the address lookup in the dashboard.
- `longitude` (double, required, nullable) — WGS84. Always set together with `latitude`.

### DayHours

One weekday in a set of opening hours. `dayOfWeek` is 0 = Sunday … 6 = Saturday. Times are local wall-clock time in Europe/Oslo, not UTC. When `isClosed` is `true`, ignore `opensAt` and `closesAt`.

- `dayOfWeek` (integer, required) — 0 = Sunday, 6 = Saturday.
- `opensAt` (string, required) — HH:MM, Europe/Oslo.
- `closesAt` (string, required) — HH:MM, Europe/Oslo.
- `isClosed` (boolean, required)

### MenuSchedule

A time window that makes a menu active. `startsAt` and `endsAt` are local wall-clock time in Europe/Oslo.

- `id` (string, required)
- `dayOfWeek` (enum, required)
  - Allowed values: `MONDAY`, `TUESDAY`, `WEDNESDAY`, `THURSDAY`, `FRIDAY`, `SATURDAY`, `SUNDAY`
- `startsAt` (string, required) — HH:MM, Europe/Oslo. Inclusive.
- `endsAt` (string, required) — HH:MM, Europe/Oslo. Exclusive.
- `priority` (integer, required)
- `isActive` (boolean, required)

### AddonGroup

A group of add-ons, such as extra toppings. The customer picks between `minSelect` and `maxSelect` of `addons`.

- `id` (string, required)
- `name` (string, required)
- `minSelect` (integer, required)
- `maxSelect` (integer, required)
- `isRequired` (boolean, required)
- `sortOrder` (integer, required)
- `tiers` (list of AddonTier, required)
- `addons` (list of Addon, required)
- `nameEn` (string, optional, nullable)

### Product

A product on the menu. Hidden and unavailable products are not included.

- `id` (string, required)
- `name` (string, required)
- `basePrice` (integer, required) — The price in øre. A chosen variant's `price` replaces it.
- `sortOrder` (integer, required)
- `variants` (list of ProductVariant, required)
- `addonGroups` (list of ProductAddonGroupsItems, required)
- `allergens` (list of string, required) — Allergen codes. Look them up in the top-level `allergens` list in `GET /menu`.
- `nameEn` (string, optional, nullable) — English name, if the restaurant has entered one.
- `description` (string, optional, nullable)
- `descriptionEn` (string, optional, nullable) — English description, if the restaurant has entered one.
- `imageUrl` (string, optional, nullable)
- `imageIsStock` (boolean, optional) — `true` means the image is a generic illustration from LettBestilt's image library, not a photo of the restaurant's own dish. Show "Illustrasjonsfoto" (illustration photo) next to the image when this is `true`.
- `isPopular` (boolean, optional) — Marked as popular by the restaurant.
- `isRecommended` (boolean, optional) — Marked as recommended by the restaurant.
- `isVegan` (boolean, optional)
- `isVegetarian` (boolean, optional)
- `isCombo` (boolean, optional) — When true, the product is a combo deal. Render the slot wizard from `comboSlots` and send `comboSelections` on order create.
- `allowedFulfillment` (enum, optional) — `PICKUP` = pickup only, `DELIVERY` = delivery only, `null` = both. The field can be missing in older or cached responses; treat that as `null`. For combo products, the products the customer picks in the slots count too (look them up via `comboSlots`). `POST /orders` rejects violations with `422 FULFILLMENT_NOT_ALLOWED`.
  - Allowed values: `PICKUP`, `DELIVERY`
- `comboSlots` (list of ComboSlot, optional)

### PublicCouponCategoriesItems

- `id` (string, optional)

### PublicCouponProductsItems

- `id` (string, optional)

### ApiV1MenuGetResponsesContentApplicationJsonSchemaUpsellProductsItems

- `id` (string, optional)
- `sortOrder` (integer, optional)
- `name` (string, optional)
- `nameEn` (string, optional, nullable)
- `description` (string, optional, nullable)
- `imageUrl` (string, optional, nullable)
- `imageIsStock` (boolean, optional)
- `basePrice` (integer, optional)
- `allowedFulfillment` (enum, optional) — Same as `Product.allowedFulfillment`. `null` means both.
  - Allowed values: `PICKUP`, `DELIVERY`

### AddonTier

Pricing tier on an addon group. Variants reference a tier via `addonTierKey`; when set, addons in this group use the tier-specific price from `Addon.tierPrices[key]` instead of the base `Addon.price`.

- `key` (string, required)
- `label` (string, required)
- `sortOrder` (integer, required)

### Addon

- `id` (string, required)
- `name` (string, required)
- `price` (integer, required) — Base price in øre. Used when the selected variant has no `addonTierKey`, or when no tier override exists.
- `sortOrder` (integer, required)
- `tierPrices` (map from string to integer, required) — Map of tier `key` → price in øre. If `variant.addonTierKey` matches a key here, use this price instead of `price`. Server re-validates on order create.
- `nameEn` (string, optional, nullable)

### ProductVariant

- `id` (string, required)
- `name` (string, required)
- `price` (integer, required) — Absolute price in øre (replaces basePrice when selected).
- `isDefault` (boolean, required)
- `sortOrder` (integer, required)
- `nameEn` (string, optional, nullable)
- `addonTierKey` (string, optional, nullable) — References an `AddonGroup.tiers[].key`. When set, addons attached to the product use tier-priced overrides for this variant.

### ProductAddonGroupsItems

A group of add-ons, such as extra toppings. The customer picks between `minSelect` and `maxSelect` of `addons`.

- `id` (string, required)
- `name` (string, required)
- `minSelect` (integer, required)
- `maxSelect` (integer, required)
- `isRequired` (boolean, required)
- `sortOrder` (integer, required)
- `tiers` (list of AddonTier, required)
- `addons` (list of Addon, required)
- `nameEn` (string, optional, nullable)

### ComboSlot

Slot in a combo-deal product. The customer must pick between `minQty` and `maxQty` products from `allowedProductIds`. If `requiredTierKey` is set, each chosen variant must have a matching `addonTierKey`.

- `id` (string, required)
- `name` (string, required)
- `sortOrder` (integer, required)
- `minQty` (integer, required)
- `maxQty` (integer, required)
- `allowedProductIds` (list of string, required) — Product IDs allowed in this slot. The full products are present elsewhere in the menu response — look them up by ID.
- `requiredTierKey` (string, optional, nullable)

## Examples

**Response**

```json
{
  "restaurant": {
    "address": {
      "line1": "string",
      "postalCode": "string",
      "city": "string",
      "country": "NO",
      "latitude": 1.1,
      "longitude": 1.1
    },
    "openingHours": [
      {
        "dayOfWeek": 1,
        "opensAt": "15:00",
        "closesAt": "21:30",
        "isClosed": true
      }
    ],
    "venueHours": [
      {
        "dayOfWeek": 1,
        "opensAt": "15:00",
        "closesAt": "21:30",
        "isClosed": true
      }
    ]
  },
  "menus": [
    {
      "id": "string",
      "name": "string",
      "isDefault": true,
      "priority": 1,
      "sortOrder": 1,
      "schedules": [
        {
          "id": "string",
          "dayOfWeek": "MONDAY",
          "startsAt": "11:00",
          "endsAt": "15:00",
          "priority": 1,
          "isActive": true
        }
      ],
      "nameEn": "string",
      "description": "string",
      "startsOn": "2026-10-12",
      "endsOn": "2026-10-18"
    }
  ],
  "categories": [
    {
      "id": "string",
      "menuId": "string",
      "name": "string",
      "nameEn": "string",
      "description": "string",
      "imageUrl": "string",
      "sortOrder": 1,
      "addonGroups": [
        {
          "id": "string",
          "name": "string",
          "minSelect": 1,
          "maxSelect": 1,
          "isRequired": true,
          "sortOrder": 1,
          "tiers": [
            {
              "key": "string",
              "label": "string",
              "sortOrder": 1
            }
          ],
          "addons": [
            {
              "id": "string",
              "name": "string",
              "price": 1,
              "sortOrder": 1,
              "tierPrices": {},
              "nameEn": "string"
            }
          ],
          "nameEn": "string"
        }
      ],
      "products": [
        {
          "id": "string",
          "name": "string",
          "basePrice": 1,
          "sortOrder": 1,
          "variants": [
            {
              "id": "string",
              "name": "string",
              "price": 1,
              "isDefault": true,
              "sortOrder": 1,
              "nameEn": "string",
              "addonTierKey": "string"
            }
          ],
          "addonGroups": [
            {
              "id": "string",
              "name": "string",
              "minSelect": 1,
              "maxSelect": 1,
              "isRequired": true,
              "sortOrder": 1,
              "tiers": [
                {
                  "key": "string",
                  "label": "string",
                  "sortOrder": 1
                }
              ],
              "addons": [
                {
                  "id": "string",
                  "name": "string",
                  "price": 1,
                  "sortOrder": 1,
                  "tierPrices": {},
                  "nameEn": "string"
                }
              ],
              "nameEn": "string"
            }
          ],
          "allergens": [
            "string"
          ],
          "nameEn": "string",
          "description": "string",
          "descriptionEn": "string",
          "imageUrl": "string",
          "imageIsStock": true,
          "isPopular": true,
          "isRecommended": true,
          "isVegan": true,
          "isVegetarian": true,
          "isCombo": true,
          "allowedFulfillment": "PICKUP",
          "comboSlots": [
            {
              "id": "string",
              "name": "string",
              "sortOrder": 1,
              "minQty": 1,
              "maxQty": 1,
              "allowedProductIds": [
                "string"
              ],
              "requiredTierKey": "string"
            }
          ]
        }
      ]
    }
  ],
  "coupons": [
    {
      "id": "string",
      "discountType": "PERCENT",
      "discountValue": 1,
      "minimumOrder": 1,
      "isAutomatic": true,
      "appliesTo": "ORDER",
      "description": "string",
      "displayName": "string",
      "displayBadge": "string",
      "usageLimit": 1,
      "usageCount": 1,
      "validFrom": "2024-01-15T09:30:00Z",
      "validTo": "2024-01-15T09:30:00Z",
      "priority": 1,
      "allowedDaysOfWeek": [
        1
      ],
      "allowedFulfillment": "PICKUP",
      "allowedTimeStart": "string",
      "allowedTimeEnd": "string",
      "bundleQuantity": 1,
      "bundleTierKey": "string",
      "maxBundlesPerOrder": 1,
      "categories": [
        {
          "id": "string"
        }
      ],
      "products": [
        {
          "id": "string"
        }
      ]
    }
  ],
  "promotions": [
    {
      "id": "string",
      "discountType": "PERCENT",
      "discountValue": 1,
      "minimumOrder": 1,
      "isAutomatic": true,
      "appliesTo": "ORDER",
      "description": "string",
      "displayName": "string",
      "displayBadge": "string",
      "usageLimit": 1,
      "usageCount": 1,
      "validFrom": "2024-01-15T09:30:00Z",
      "validTo": "2024-01-15T09:30:00Z",
      "priority": 1,
      "allowedDaysOfWeek": [
        1
      ],
      "allowedFulfillment": "PICKUP",
      "allowedTimeStart": "string",
      "allowedTimeEnd": "string",
      "bundleQuantity": 1,
      "bundleTierKey": "string",
      "maxBundlesPerOrder": 1,
      "categories": [
        {
          "id": "string"
        }
      ],
      "products": [
        {
          "id": "string"
        }
      ]
    }
  ],
  "upsell": {
    "isActive": true,
    "mode": "POPULAR",
    "products": [
      {
        "id": "string",
        "sortOrder": 1,
        "name": "string",
        "nameEn": "string",
        "description": "string",
        "imageUrl": "string",
        "imageIsStock": true,
        "basePrice": 1,
        "allowedFulfillment": "PICKUP"
      }
    ]
  }
}
```

**SDK Code**

```python
import requests

url = "https://www.lettbestilt.no/api/v1/menu"

querystring = {"slug":"slug"}

headers = {"Authorization": "Bearer <token>"}

response = requests.get(url, headers=headers, params=querystring)

print(response.json())
```

```javascript
const url = 'https://www.lettbestilt.no/api/v1/menu?slug=slug';
const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

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

```go
package main

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

func main() {

	url := "https://www.lettbestilt.no/api/v1/menu?slug=slug"

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

	req.Header.Add("Authorization", "Bearer <token>")

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

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

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

}
```

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

url = URI("https://www.lettbestilt.no/api/v1/menu?slug=slug")

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

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <token>'

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

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

HttpResponse<String> response = Unirest.get("https://www.lettbestilt.no/api/v1/menu?slug=slug")
  .header("Authorization", "Bearer <token>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://www.lettbestilt.no/api/v1/menu?slug=slug', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://www.lettbestilt.no/api/v1/menu?slug=slug");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = ["Authorization": "Bearer <token>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://www.lettbestilt.no/api/v1/menu?slug=slug")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
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()
```