Get Store Menu Timings

curl --request GET \
  --url 'https://api.example.com/stores/{{store_id}}/menu/timing?menu_ids=%7B{menu_ids}%7D'

const options = {method: 'GET'};

fetch('https://api.example.com/stores/{{store_id}}/menu/timing?menu_ids=%7B{menu_ids}%7D', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.example.com/stores/{{store_id}}/menu/timing?menu_ids=%7B{menu_ids}%7D",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

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

func main() {

	url := "https://api.example.com/stores/{{store_id}}/menu/timing?menu_ids=%7B{menu_ids}%7D"

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

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

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

	fmt.Println(string(body))

}

require 'uri'
require 'net/http'

url = URI("https://api.example.com/stores/{{store_id}}/menu/timing?menu_ids=%7B{menu_ids}%7D")

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

request = Net::HTTP::Get.new(url)

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

GET

stores

{store_id}

timing?menu_ids=

{menu_ids}

Get Store Menu Timings

curl --request GET \
  --url 'https://api.example.com/stores/{{store_id}}/menu/timing?menu_ids=%7B{menu_ids}%7D'

const options = {method: 'GET'};

fetch('https://api.example.com/stores/{{store_id}}/menu/timing?menu_ids=%7B{menu_ids}%7D', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.example.com/stores/{{store_id}}/menu/timing?menu_ids=%7B{menu_ids}%7D",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

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

func main() {

	url := "https://api.example.com/stores/{{store_id}}/menu/timing?menu_ids=%7B{menu_ids}%7D"

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

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

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

	fmt.Println(string(body))

}

require 'uri'
require 'net/http'

url = URI("https://api.example.com/stores/{{store_id}}/menu/timing?menu_ids=%7B{menu_ids}%7D")

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

request = Net::HTTP::Get.new(url)

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

This endpoint returns detailed timing information for specific menus within a store, allowing applications to determine menu availability based on current time and operating schedules.

Menu timing information is crucial for determining real-time menu availability and ensuring customers see only menus that are currently operational based on the store’s schedule.

Path Parameters

string

required

The unique identifier of the store that owns the menus

Query Parameters

Comma-separated list of menu IDs to retrieve timing information for

Timing Information Usage

Real-Time Availability

Determine which menus are currently available
Check if menus will be available at future times
Calculate remaining time until menu closes
Identify upcoming menu availability windows

Operational Planning

Plan staff schedules based on menu operating hours
Coordinate inventory management with menu availability
Schedule maintenance during menu closure periods
Align marketing campaigns with menu operating hours

Customer Experience

Display accurate menu availability to customers
Show countdown timers for menu closing times
Provide advance notice of menu availability changes
Enable pre-ordering for future menu availability periods

System Integration

Synchronize with point-of-sale systems
Coordinate with delivery platform schedules
Update inventory systems based on menu timing
Integrate with marketing automation platforms

Multiple Menu Support: This endpoint can retrieve timing information for multiple menus simultaneously, making it efficient for applications that need to check availability across several menu options.

Time Zone Considerations: Menu timing information should be interpreted in the store’s local time zone for accurate availability calculations.

Use Cases

Common Timing Query Scenarios

Customer Application Features

Show current menu availability status
Display “opening soon” or “closing soon” messages
Enable advance ordering for future menu periods
Provide estimated wait times for menu availability

Operational Management

Monitor menu availability across multiple locations
Plan staff scheduling based on menu operating hours
Coordinate marketing campaigns with menu availability
Manage inventory replenishment timing

Partner Integration

Synchronize delivery platform availability
Update third-party ordering systems
Coordinate with marketing automation tools
Integrate with business intelligence systems

Administrative Functions

Monitor menu timing compliance
Analyze menu utilization patterns
Optimize menu schedules for business performance
Generate operational reports and insights

Timing Calculation Logic

How Menu Timing Works

Daily Schedule Processing

Each menu can have multiple time periods per day
Days of the week are processed independently
Closed days are clearly identified in timing data
Special schedules override default timing

Current Time Evaluation

System compares current time to menu operating hours
Time zone conversion ensures accurate local time comparison
Overlap periods are handled for complex schedules
Transition times are calculated for opening/closing events

Future Availability Prediction

Next available period calculation for closed menus
Remaining operating time for currently open menus
Weekly schedule projection for advance planning
Holiday and special event schedule integration

Complex Schedule Handling

Multiple opening periods per day (e.g., lunch breaks)
Overnight operations crossing midnight
Seasonal schedule variations
Emergency schedule modifications

Response Data Structure

Expected Timing Information

Menu Timing Objects

Individual timing data for each requested menu
Current availability status (open/closed)
Next availability window information
Complete weekly schedule details

Operating Hours Details

Start and end times for each operating period
Day of week specifications
Closed day indicators
Special schedule annotations

Availability Calculations

Time remaining until closure (for open menus)
Time until next opening (for closed menus)
Duration of next available period
Weekly availability summary

Metadata and Context

Menu identification and naming
Store time zone information
Last update timestamps
Schedule version information

Performance Optimization

Timing Query Performance

Efficient Data Retrieval

Optimized queries for multiple menu timing data
Indexed database operations for fast response
Cached timing calculations for frequently requested menus
Minimized data transfer for mobile applications

Real-Time Processing

Immediate timing calculations based on current time
Dynamic availability status determination
Efficient schedule comparison algorithms
Optimized time zone conversion processing

Scalability Considerations

Concurrent request handling for high-traffic periods
Database connection pooling for multiple menu queries
Memory-efficient data structures for timing calculations
Load balancing for geographic distribution

Caching Strategies

Menu timing data caching with appropriate expiration
Schedule calculation result caching
Time zone conversion result caching
Strategic cache invalidation on schedule updates

Integration Best Practices

Implementation Guidelines

Request Optimization

Batch multiple menu IDs in single requests
Cache timing data appropriately for application needs
Implement efficient polling strategies for real-time updates
Use compression for large timing datasets

Error Handling

Handle cases where menu IDs don’t exist
Manage time zone conversion errors gracefully
Implement fallback behavior for service failures
Provide meaningful error messages to applications

Data Processing

Parse timing data efficiently for application use
Handle complex schedule patterns appropriately
Implement proper time zone handling
Cache processed timing calculations when possible

User Experience

Display timing information clearly to users
Provide advance notice of menu closing times
Show alternative menu options when current menus are closed
Update timing displays in real-time

Error Handling

Common Timing Query Errors

Invalid Menu IDs

{
  "error": "Invalid menu IDs",
  "message": "One or more menu IDs do not exist",
  "invalid_ids": ["invalid-menu-id-1", "invalid-menu-id-2"]
}

Store Not Found

{
  "error": "Store not found",
  "message": "The specified store does not exist",
  "store_id": "invalid-store-id"
}

No Timing Data

{
  "message": "No timing data available for specified menus",
  "menu_ids": ["menu-1", "menu-2"]
}

Service Error

{
  "error": "Timing service unavailable",
  "message": "Unable to retrieve timing information at this time"
}

Business Applications

Business Value and Applications

Revenue Optimization

Maximize menu availability during peak demand periods
Optimize staff scheduling based on menu timing patterns
Coordinate promotional activities with menu availability
Analyze timing impact on customer behavior and sales

Customer Satisfaction

Provide accurate menu availability information
Reduce customer frustration with unavailable menus
Enable advance planning for customer orders
Improve overall customer experience with reliable timing data

Operational Efficiency

Streamline staff scheduling based on menu operating hours
Optimize inventory management with timing-based planning
Coordinate maintenance activities during menu closure periods
Improve resource allocation across multiple menu periods

Strategic Planning

Analyze menu timing effectiveness for business growth
Identify opportunities for schedule optimization
Support expansion planning with timing pattern analysis
Enable data-driven decisions for menu schedule adjustments

API Documentation - Legacy

API Documentation - Latest

Get Store Menu Timings

Path Parameters

Query Parameters

Use Cases

Timing Calculation Logic

Response Data Structure

Performance Optimization

Integration Best Practices

Error Handling

Business Applications

​Path Parameters

​Query Parameters

​Use Cases

​Timing Calculation Logic

​Response Data Structure

​Performance Optimization

​Integration Best Practices

​Error Handling

​Business Applications

Path Parameters

Query Parameters

Use Cases

Timing Calculation Logic

Response Data Structure

Performance Optimization

Integration Best Practices

Error Handling

Business Applications