Skip to main content
GET
/
stores
/
{store_id}
/
menu
/
Get All Active Menu of Store
curl --request GET \
  --url 'https://api.example.com/stores/{{store_id}}/menu/'
import requests

url = "https://api.example.com/stores/{{store_id}}/menu/"

response = requests.get(url)

print(response.text)
const options = {method: 'GET'};

fetch('https://api.example.com/stores/{{store_id}}/menu/', 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/",
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/"

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

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

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

fmt.Println(string(body))

}
HttpResponse<String> response = Unirest.get("https://api.example.com/stores/{{store_id}}/menu/")
.asString();
require 'uri'
require 'net/http'

url = URI("https://api.example.com/stores/{{store_id}}/menu/")

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 all active menus associated with a specific store, providing essential information for menu management and customer-facing applications.
This endpoint focuses on active menus only, making it ideal for customer-facing applications and operational systems that need to display currently available menu options.

Path Parameters

store_id
string
required
The unique identifier of the store to retrieve active menus for
Menu Status Requirements
  • Only menus with “active” status are returned
  • Inactive or archived menus are excluded from results
  • Deleted menus are not included in the response
  • Draft menus are filtered out of the results
Operational Considerations
  • Active menus represent current customer offerings
  • These menus are available for order processing
  • Operating hours determine actual availability within active menus
  • Menu rules and item associations apply to active menus
Customer Experience
  • Active menus are what customers see in applications
  • These menus drive ordering and checkout processes
  • Menu availability affects customer purchasing decisions
  • Real-time status ensures accurate customer information
Real-Time Data: This endpoint provides real-time menu status information, ensuring customers and operational systems have access to current menu availability.
Performance Optimization: Since this endpoint filters for active menus only, it typically returns faster responses and is optimized for frequent access by customer-facing applications.

Use Cases

Customer-Facing Applications
  • Mobile app menu displays
  • Website menu listings
  • Point-of-sale system menu options
  • Kiosk menu presentations
Operational Systems
  • Order management system integration
  • Inventory tracking and management
  • Staff training and reference materials
  • Kitchen display system coordination
Partner Integrations
  • Delivery platform menu synchronization
  • Third-party ordering system integration
  • Marketing platform data feeds
  • Analytics and reporting systems
Administrative Functions
  • Current menu status monitoring
  • Active menu performance tracking
  • Operational dashboard displays
  • Real-time business intelligence

Response Format

Menu Object Array
  • Array of active menu objects
  • Each menu contains complete configuration data
  • Operating hours included for each menu
  • Item counts and statistics provided
Essential Menu Information
  • Menu identification and naming
  • Current status and configuration
  • Operating schedule details
  • Item and category statistics
Metadata and Timestamps
  • Creation and modification dates
  • User information for audit trails
  • External system integration IDs
  • Deletion and archival status

Integration Patterns

Real-Time Menu Display
  • Fetch active menus for immediate display
  • Update menu information based on current time
  • Filter by operating hours for current availability
  • Refresh data periodically for accuracy
Caching Strategies
  • Cache active menu data for performance
  • Implement cache invalidation on menu updates
  • Balance data freshness with response speed
  • Consider user location and time zone factors
Error Handling
  • Handle cases where no active menus exist
  • Provide fallback options for system failures
  • Implement graceful degradation for partial failures
  • Log errors for operational monitoring
Performance Optimization
  • Minimize request frequency for high-traffic applications
  • Use appropriate data compression
  • Implement efficient data parsing
  • Monitor response times and optimize accordingly

Business Logic

Menu Activation Criteria
  • Menu must have “active” status
  • Store must be operational and accessible
  • Menu configuration must be complete and valid
  • Operating hours must be properly configured
Time-Based Availability
  • Active menus may still be time-restricted
  • Operating hours determine actual customer access
  • Special schedules may override default availability
  • Holiday and event schedules affect menu access
Priority and Default Handling
  • Default menus take precedence in customer displays
  • Menu priority affects ordering in lists
  • Specialized menus may override default options
  • Business rules determine menu presentation order
Dynamic Updates
  • Menu status changes are reflected immediately
  • Real-time updates ensure accurate customer information
  • System synchronization maintains consistency
  • Operational changes are propagated quickly

Error Scenarios

No Active Menus
{
  "message": "No active menus found for this store",
  "data": [],
  "store_id": "store-123"
}
Store Not Found
{
  "error": "Store not found",
  "message": "The specified store does not exist",
  "store_id": "invalid-store-id"
}
Access Denied
{
  "error": "Access denied",
  "message": "Insufficient permissions to access store menus"
}
Service Unavailable
{
  "error": "Service temporarily unavailable",
  "message": "Menu service is currently experiencing issues"
}

Performance Considerations

Response Time Optimization
  • Active menu filtering reduces response size
  • Database indexing on menu status improves query speed
  • Caching strategies reduce server load
  • Efficient data serialization minimizes transfer time
Scalability Factors
  • High-frequency access patterns expected
  • Multiple concurrent requests from customer applications
  • Peak usage during meal times and promotional periods
  • Geographic distribution of requests
Resource Management
  • Database connection pooling for concurrent access
  • Memory management for large menu datasets
  • Network bandwidth optimization for mobile clients
  • CPU resource allocation for real-time processing
Monitoring and Alerts
  • Response time monitoring for performance tracking
  • Error rate tracking for service reliability
  • Usage pattern analysis for capacity planning
  • Alert systems for performance degradation

Data Consistency

Real-Time Updates
  • Menu status changes are immediately reflected
  • Operating hour modifications take effect instantly
  • Item availability updates are propagated quickly
  • System-wide synchronization ensures consistency
Cache Management
  • Appropriate cache invalidation on menu changes
  • Consistent data across multiple application instances
  • Time-based cache expiration for data freshness
  • Geographic cache distribution for global applications
Synchronization Protocols
  • Database replication ensures data availability
  • Event-driven updates maintain system consistency
  • Conflict resolution for concurrent modifications
  • Audit trails for change tracking and rollback
Quality Assurance
  • Data validation ensures menu integrity
  • Automated testing verifies API reliability
  • Monitoring systems track data quality metrics
  • Error detection and correction mechanisms