Introduction


# Introduction

Welcome to the documentation for ChefGPT API, your gateway to culinary creativity powered by artificial intelligence. This comprehensive guide is tailored for software developers like you who want to harness the culinary capabilities of ChefGPT to enhance your applications. Whether you're building a meal planning app, a recipe recommendation service, or anything food-related, ChefGPT API is your trusted companion.

## About ChefGPT API

ChefGPT API empowers developers with a range of endpoints to seamlessly integrate AI-generated recipes and meal plans into their software solutions. Our mission is to simplify the process of creating delightful culinary experiences for your users. Below are the key endpoints at your disposal:

- recipe-from-ingredients: Craft recipes based on user-provided ingredients.
- recipe: Generate recipes tailored to specific criteria.
- recipe-from-macros: Create recipes aligned with target macronutrient goals.
- pairings: Offer expert wine or beer pairings for a given meal.
- meal-plan: Automatically generate meal plans based on user inputs.

## Why Choose ChefGPT API?

In a world where culinary innovation is at the forefront of user experiences, ChefGPT API stands out for several reasons:

- **Artificial Intelligence Expertise:** Our API leverages state-of-the-art AI algorithms to deliver high-quality culinary suggestions.
- **Versatile Integration:** Seamlessly integrate ChefGPT API into your applications, whether you're working on web, mobile, or desktop platforms.
- **Enhanced User Engagement:** Elevate user satisfaction by offering personalized recipes and meal plans, keeping them engaged with your platform.
- **Time Efficiency:** Eliminate the need for manual recipe creation or meal planning by automating these processes with ChefGPT.

## Getting Started

This documentation will guide you through the intricacies of using ChefGPT API effectively. We'll walk you through the endpoints, provide detailed examples, and offer best practices to ensure a smooth integration process. Whether you're a seasoned developer or new to AI-powered solutions, you'll find valuable insights here.

## Tech Stack

ChefGPT API is built on a robust technical foundation, ensuring reliability and scalability for your projects:

- **AI Core:** Utilizes cutting-edge AI technologies for recipe and meal plan generation.
- **API Framework:** A developer-friendly API built for easy integration.
- **Security Measures:** Ensures data privacy and compliance with industry standards.
- **Scalability:** Designed to handle increasing workloads as your application grows.
- **Deployment:** Easy to deploy widgets available to go live FAST!

## Support and Assistance

At ChefGPT, we're committed to your success. If you encounter any challenges, have questions, or need assistance, our dedicated support team is here to help. You can rely on us for prompt responses, guidance, and solutions to ensure your project's success.

Thank you for choosing ChefGPT API. Let's embark on a culinary journey together and bring the joy of AI-powered cooking to your users. Happy coding!

Introduction to ChefGPT API: API Endpoints to generate Recipes an Meal Plans with Artificial Intelligence

Getting Started

API Key


Your secret API Key is your access key to use ChefGPT API Services. Each organization can create and have only one API Key active at any given moment in time. 

⚠️ Important: Do not share your API key with others, or expose it in the browser or other client-side code. You are the sole responsible of keeping your API Key safe and avoid any unintended usage of your key.

## Creating an API Key

To create an API Key, follow these steps:
- Access the API Key section: Navigate to the [API Key section](api.chefgpt.xyz/apiKey).
- Create an API Key: Click on "Create New API Key" Button.

Note: Clicking on the "Create New API Key" while an API Key is already in use, it will result in the revoking of the existing one. This action is irreversible.

Learn how to create an API Key to use ChefGPT API.

How to Create an API Key


## Deleting an API Key

To Delete an API Key, follow these steps:
- Access the API Key section: Navigate to the [API Key section](api.chefgpt.xyz/apiKey).
- Delete an API Key: Click on "Delete API Key" Button.

Note: Clicking on the "Delete New API Key" will revoke the currently active API Key. This action is irreversible.

Learn how to Delete an API Key to use ChefGPT API.

How to Delete an API Key

Endpoints


## Introduction

This API route allows you to generate a recipe based on a set of provided ingredients and optional constraints. It provides two endpoints, each with a different response format:

- **JSON Route**: Returns the recipe details as JSON.
- **Readable Stream Route**: Streams the recipe details in a readable stream.

## Authentication

To access these endpoints, you must include an `Authorization` header with a valid API key.

## Common Request Parameters

Both routes accept the following request parameters:

- `ingredients` (array, required): An array of strings representing ingredients.
- `mealType` (enum, optional): The type of meal you want to create ['breakfast', 'lunch', 'dinner', 'snack', 'dessert']. Default: No meal restrictions.
- `kitchenTools` (array, optional): An array of strings representing kitchen tools available for cooking. Default: No tools restrictions.
- `preparationTime` (number, optional): The maximum preparation time in minutes. Default: No time restrictions.
- `servings` (number, optional): The amount of servings the recipe should yield. Default: 1 serving.
- `difficulty` (enum, optional): The desired difficulty level of the recipe ['novice', 'intermediate', 'expert']. Default: No difficulty restrictions.
- `measurement` (string, required): The measurement system used in the output ['imperial', 'metric']. Default: Metric.

## JSON Route Details

### Endpoint

`POST /api/generate/recipe-from-ingredients`

### Request Example

```json
POST /api/generate/recipe-from-ingredients
Headers:
{
  "Authorization": "YOUR_API_KEY"
}
Body:
{
  "ingredients": ["Chicken 500 grams","2 Cups of Rice "],
  "mealType": "dinner",
  "kitchenTools": ["oven", "pot"],
  "preparationTime": 30,
  "servings": 2,
  "difficulty": "intermediate"
}
```

### Response (JSON)

- **Status Code:** 200 (OK)
- **Content-Type:** application/json

```json
{
  "recipeName": "Delicious Chicken and Rice",
  "ingredients": [
    {
      "name": "Chicken",
      "unit": "grams",
      "amount": 500
    },
    {
      "name": "Rice",
      "unit": "cups",
      "amount": 2
    },
    // ... other ingredients
  ],
  "instructions": [
    "1. Preheat the oven to 350°F.",
    "2. Season the chicken with salt and pepper.",
    // ... other instructions
  ],
  "difficulty": "intermediate",
  "macros": {
    "carbs": {
      "amount": 40,
      "unit": "grams"
    },
    // ... other macros
  },
  "preparationTime": 30,
  "servings": 2,
  "kitchenToolsUsed": ["oven", "pot"]
}
```

## Readable Stream Route Details

### Endpoint

`POST /api/generate/stream/recipe-from-ingredients`

### Request Example

```json
POST /api/generate/stream/recipe-from-ingredients
Headers:
{
  "Authorization": "YOUR_API_KEY"
}
Body:
{
  "ingredients": ["Chicken 500 grams","2 Cups of Rice "],
  "mealType": "dinner",
  "kitchenTools": ["oven", "pot"],
  "preparationTime": 30,
  "servings": 2,
  "difficulty": "intermediate"
}
```

### Response (Readable Stream)

- **Status Code:** 200 (OK)
- **Content-Type:** application/json (Streaming)

```json
{
  "recipeName": "Delicious Chicken and Rice",
  "ingredients": [
    {
      "name": "Chicken",
      "unit": "grams",
      "amount": 500
    },
    {
      "name": "Rice",
      "unit": "cups",
      "amount": 2
    },
    // ... other ingredients
  ],
  "instructions": [
    "1. Preheat the oven to 350°F.",
    "2. Season the chicken with salt and pepper.",
    // ... other instructions
  ],
  "difficulty": "intermediate",
  "macros": {
    "carbs": {
      "amount": 40,
      "unit": "grams"
    },
    // ... other macros
  },
  "preparationTime": 30,
  "servings": 2,
  "kitchenToolsUsed": ["oven", "pot"]
}
```

The response is streamed and varies in size based on the generated content. On the client side, you should process the stream accordingly.

#### Handling the Readable Stream Response (JavaScript Example)
To handle the Readable Stream response in JavaScript, you can use the following code as an example:

```javascript
const responseStream = await fetch('/api/generate/stream/recipe-from-ingredients', {
  method: 'POST',
  headers: {
    'Authorization': 'YOUR_API_KEY',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
  "ingredients": "ingredients": ["Chicken 500 grams","2 Cups of Rice "],
  "mealType": "dinner",
  "kitchenTools": ["oven", "pot"],
  "preparationTime": 30,
  "servings": 2,
  "difficulty": "intermediate"
}),
});

// Process the stream
responseStream.then(async (response) => {
  const reader = response.body.getReader();
  const decoder = new TextDecoder();

  while (!done) {
      const { value, done: doneReading } = await reader.read();

      done = doneReading; // Break the loop if stream completed
      const newValue = decoder.decode(value);
      chunks = chunks + newValue;
    }

    // Parses the completed response (recipe data)
    const recipeData = JSON.parse(chunks);

    // Handle the recipe data as needed
    console.log(recipeData);

});
```

## Execution Time

As responses are generated on the fly through AI, response time will vary depending on the lenght of the response. Approximate time for response is 10s for the 'recipe-from-ingredients' endpoint.

## Error Responses

Both routes return specific error responses for various scenarios:

- **Missing API Key (Status Code: 403)**:
  - Response: `No API Key in request`
- **Invalid API Key (Status Code: 403)**:
  - Response: `Invalid API Key`
- **Missing Required Inputs (Status Code: 400)**:
  - Response: `Required inputs not provided`
- **Inactive Subscription (Status Code: 403)**:
  - Response: `You don't have an active subscription`

The 'recipe-from-ingredients' endpoint allows you to generate recipes from an available set of ingredients and additional criterias are available to fine ture the output. Customers have the choice of receiving the response as JSON or as a readable stream.

Recipe From Ingredients


## Introduction

This API allows you to generate meal recipes based on specific criteria. It provides two endpoints, each with a different response format:

- **JSON Route**: Returns the recipe details as JSON.
- **Readable Stream Route**: Streams the recipe details in a readable stream.

## Authentication

To access these endpoints, you must include an `Authorization` header with a valid API key.

## Common Request Parameters

Both routes accept the following request parameters:

- `recipe` (string, required): A statement describing the desired recipe.
- `diet` (string, optional): Dietary preference ['vegetarian','pescatarian','vegan','diaryfree','glutenfree','keto','paleo']. Default: No diet restrictions.
- `servings` (number, optional): The number of servings for the recipe.  Default: 1 Serving.
- `preparationTime` (number, optional): The maximum preparation time in minutes. Default: No time restrictions.
- `difficulty` (string, optional): The difficulty level of the recipe ['novice', 'intermediate', 'expert']. Default: No difficulty restrictions.
- `measurement` (string, required): The measurement system used in the output ['imperial', 'metric']. Default: Metric.

## JSON Route Details

### Endpoint

`POST /api/generate/recipe`

### Request Example

```json
POST /api/generate/recipe
Headers:
{
  "Authorization": "YOUR_API_KEY"
}
Body:
{
  "recipe": "Beef Wellington",
  "diet": "vegetarian",
  "servings": 4,
  "preparationTime": 30,
  "difficulty": "intermediate"
}
```

### Response (JSON)

- **Status Code:** 200 (OK)
- **Content-Type:** application/json

```json
{
  "recipeName": "Delicious Tomato Basil Pasta",
  "difficulty": "intermediate",
  "kitchenToolsUsed": ["Saucepan", "Knife", "Colander"],
  "instructions": ["1. Boil pasta.", "2. Make tomato sauce.", "3. Mix pasta and sauce."],
  "preparationTime": 30,
  "servings": 4,
  "ingredients": [
    { "name": "Pasta", "unit": "grams", "amount": 250 },
    { "name": "Tomatoes", "unit": "grams", "amount": 300 },
    { "name": "Basil", "unit": "grams", "amount": 10 }
  ],
  "macros": {
    "carbs": { "amount": 45, "unit": "grams" },
    "fats": { "amount": 10, "unit": "grams" },
    "proteins": { "amount": 8, "unit": "grams" },
    "calories": { "amount": 280, "unit": "kcal" }
  }
}
```

## Readable Stream Route Details

### Endpoint

`POST /api/generate/stream/recipe`

### Request Example

```json
POST /api/generate/stream/recipe
Headers:
{
  "Authorization": "YOUR_API_KEY"
}
Body:
{
  "recipe": "Beef Wellington",
  "diet": "vegetarian",
  "servings": 4,
  "preparationTime": 30,
  "difficulty": "intermediate"
}
```

### Response (Readable Stream)

- **Status Code:** 200 (OK)
- **Content-Type:** application/json (Streaming)

```json
{
  "recipeName": "Delicious Tomato Basil Pasta",
  "difficulty": "intermediate",
  "kitchenToolsUsed": ["Saucepan", "Knife", "Colander"],
  "instructions": ["1. Boil pasta.", "2. Make tomato sauce.", "3. Mix pasta and sauce."],
  "preparationTime": 30,
  "servings": 4,
  "ingredients": [
    { "name": "Pasta", "unit": "grams", "amount": 250 },
    { "name": "Tomatoes", "unit": "grams", "amount": 300 },
    { "name": "Basil", "unit": "grams", "amount": 10 }
  ],
  "macros": {
    "carbs": { "amount": 45, "unit": "grams" },
    "fats": { "amount": 10, "unit": "grams" },
    "proteins": { "amount": 8, "unit": "grams" },
    "calories": { "amount": 280, "unit": "kcal" }
  }
}
```

The response is streamed and varies in size based on the generated content. On the client side, you should process the stream accordingly.

#### Handling the Readable Stream Response (JavaScript Example)
To handle the Readable Stream response in JavaScript, you can use the following code as an example:

```javascript
const responseStream = fetch('/api/generate/stream/recipe', {
  method: 'POST',
  headers: {
    'Authorization': 'YOUR_API_KEY',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "recipe": "Beef Wellington",
    "diet": "vegetarian",
    "servings": 4,
    "preparationTime": 30,
    "difficulty": "intermediate"
  }),
});

// Process the stream
responseStream.then(async (response) => {
  const reader = response.body.getReader();
  const decoder = new TextDecoder();

  while (!done) {
      const { value, done: doneReading } = await reader.read();

      done = doneReading; // Break the loop if stream completed
      const newValue = decoder.decode(value);
      chunks = chunks + newValue;
    }

    // Parses the completed response (recipe data)
    const recipeData = JSON.parse(chunks);

    // Handle the recipe data as needed
    console.log(recipeData);

});
```
## Execution Time

As responses are generated on the fly through AI, response time will vary depending on the lenght of the response. Approximate time for response is 10s for the 'recipe' endpoint.

## Error Responses

Both routes return specific error responses for various scenarios:

- **Missing API Key (Status Code: 403)**:
  - Response: `No API Key in request`
- **Invalid API Key (Status Code: 403)**:
  - Response: `Invalid API Key`
- **Missing Required Inputs (Status Code: 400)**:
  - Response: `Required inputs not provided`
- **Inactive Subscription (Status Code: 403)**:
  - Response: `You don't have an active subscription`

The 'recipe' endpoint allows you to generate recipes based on provided criteria, including recipe statement, dietary preferences, servings, preparation time, and difficulty level, with the choice of receiving the response as JSON or as a readable stream.

Recipe


## Introduction

This API route allows you to generate a recipe based on macronutrient distributions and optional constraints. It provides two endpoints, each with a different response format:

- **JSON Route**: Returns the recipe details as JSON.
- **Readable Stream Route**: Streams the recipe details in a readable stream.

## Authentication

To access these endpoints, you must include an `Authorization` header with a valid API key.

## Common Request Parameters

Both routes accept the following request parameters:

- `carbs` (number, required): The amount of carbohydrates in grams.
- `proteins` (number, required): The amount of proteins in grams.
- `fats` (number, required): The amount of fats in grams.
- `diet` (string, optional): The dietary preference ['vegetarian','pescatarian','vegan','diaryfree','glutenfree','keto','paleo']. Default: No diet restrictions.
- `meal` (string, optional): The meal type ['breakfast', 'lunch', 'dinner', 'snack', 'dessert']. Default: No meal restrictions.
- `measurement` (string, required): The measurement system used in the output ['imperial', 'metric']. Default: Metric.

## JSON Route Details

### Endpoint

`POST /api/generate/recipe-from-macros`

### Request Example

```json
POST /api/generate/recipe-from-macros
Headers:
{
  "Authorization": "YOUR_API_KEY"
}
Body:
{
  "carbs": 100,
  "proteins": 50,
  "fats": 30,
  "diet": "vegetarian",
  "meal": "lunch"
}
```

### Response (JSON)

- **Status Code:** 200 (OK)
- **Content-Type:** application/json

```json
{
  "recipeName": "Delicious Chicken and Rice",
  "ingredients": [
    {
      "name": "Chicken",
      "unit": "grams",
      "amount": 500
    },
    {
      "name": "Rice",
      "unit": "cups",
      "amount": 2
    },
    // ... other ingredients
  ],
  "instructions": [
    "1. Preheat the oven to 350°F.",
    "2. Season the chicken with salt and pepper.",
    // ... other instructions
  ],
  "difficulty": "intermediate",
  "macros": {
    "carbs": {
      "amount": 40,
      "unit": "grams"
    },
    // ... other macros
  },
  "preparationTime": 30,
  "servings": 1,
  "kitchenToolsUsed": ["oven", "pot"]
}
```

## Readable Stream Route Details

### Endpoint

`POST /api/generate/stream/recipe-from-macros`

### Request Example

```json
POST /api/generate/stream/recipe-from-macros
Headers:
{
  "Authorization": "YOUR_API_KEY"
}
Body:
{
  "carbs": 100,
  "proteins": 50,
  "fats": 30,
  "diet": "vegetarian",
  "meal": "lunch"
}
```

### Response (Readable Stream)

- **Status Code:** 200 (OK)
- **Content-Type:** application/json (Streaming)

```json
{
  "recipeName": "Delicious Chicken and Rice",
  "ingredients": [
    {
      "name": "Chicken",
      "unit": "grams",
      "amount": 500
    },
    {
      "name": "Rice",
      "unit": "cups",
      "amount": 2
    },
    // ... other ingredients
  ],
  "instructions": [
    "1. Preheat the oven to 350°F.",
    "2. Season the chicken with salt and pepper.",
    // ... other instructions
  ],
  "difficulty": "intermediate",
  "macros": {
    "carbs": {
      "amount": 40,
      "unit": "grams"
    },
    // ... other macros
  },
  "preparationTime": 30,
  "servings": 1,
  "kitchenToolsUsed": ["oven", "pot"]
}
```

The response is streamed and varies in size based on the generated content. On the client side, you should process the stream accordingly.

#### Handling the Readable Stream Response (JavaScript Example)
To handle the Readable Stream response in JavaScript, you can use the following code as an example:

```javascript
const responseStream = fetch('/api/generate/stream/recipe-from-macros', {
  method: 'POST',
  headers: {
    'Authorization': 'YOUR_API_KEY',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
  "ingredients": [
    {
      "name": "Chicken",
      "unit": "grams",
      "amount": 500
    },
    {
      "name": "Rice",
      "unit": "cups",
      "amount": 2
    }
  ],
  "mealType": "dinner",
  "kitchenTools": ["oven", "pot"],
  "preparationTime": 30,
  "difficulty": "intermediate"
}),
});

// Process the stream
responseStream.then(async (response) => {
  const reader = response.body.getReader();
  const decoder = new TextDecoder();

  while (!done) {
      const { value, done: doneReading } = await reader.read();

      done = doneReading; // Break the loop if stream completed
      const newValue = decoder.decode(value);
      chunks = chunks + newValue;
    }

    // Parses the completed response (recipe data)
    const recipeData = JSON.parse(chunks);

    // Handle the recipe data as needed
    console.log(recipeData);

});
```
## Execution Time

As responses are generated on the fly through AI, response time will vary depending on the lenght of the response. Approximate time for response is 10s for the 'recipe-from-macros' endpoint.

## Error Responses

Both routes return specific error responses for various scenarios:

- **Missing API Key (Status Code: 403)**:
  - Response: `No API Key in request`
- **Invalid API Key (Status Code: 403)**:
  - Response: `Invalid API Key`
- **Missing Required Inputs (Status Code: 400)**:
  - Response: `Required inputs not provided`
- **Inactive Subscription (Status Code: 403)**:
  - Response: `You don't have an active subscription`

The 'recipe-from-macros' endpoint allows you to generate recipes from an available set of ingredients and additional criterias are available to fine ture the output. Customers have the choice of receiving the response as JSON or as a readable stream.

Recipe From Macros


## Introduction

This API route allows you to generate beverage pairings that go well with a given meal. It provides two endpoints, each with a different response format:

- **JSON Route**: Returns the pairings details as JSON.
- **Readable Stream Route**: Streams the pairings details in a readable stream.

## Authentication

To access these endpoints, you must include an `Authorization` header with a valid API key.

## Common Request Parameters

Both routes accept the following request parameters:

- `drinkType` (enum, required): Specifies the type of beverage you want recommendations for ['beer', 'wine']
- `meal` (string, required): Describes the meal for which you want beverage pairings.

## JSON Route Details

### Endpoint

`POST /api/generate/pairings`

### Request Example

```json
POST /api/generate/pairings
Headers:
{
  "Authorization": "YOUR_API_KEY"
}
Body:
{
  "drinkType": "wine",
  "meal": "Grilled Salmon"
}

```

### Response (JSON)

- **Status Code:** 200 (OK)
- **Content-Type:** application/json

```json
[
  {
    "rank": 1,
    "producer": "Winery A",
    "name": "Wine 1",
    "styles": "Red",
    "country": "US",
    "tasteProfile": {
      "sweetness": "Dry",
      "acidity": "Medium",
      "tannin": "High",
      "body": "Full"
    },
    "alcolVolume": "13%",
    "priceRange": "$$$"
  },
  // Additional pairings...
]
```

## Readable Stream Route Details

### Endpoint

`POST /api/generate/stream/pairings`

### Request Example

```json
POST /api/generate/stream/pairings
Headers:
{
  "Authorization": "YOUR_API_KEY"
}
Body:
{
  "drinkType": "wine",
  "meal": "Grilled Salmon"
}

```

### Response (Readable Stream)

- **Status Code:** 200 (OK)
- **Content-Type:** application/json (Streaming)

```json
[
  {
    "rank": 1,
    "producer": "Winery A",
    "name": "Wine 1",
    "styles": "Red",
    "country": "US",
    "tasteProfile": {
      "sweetness": "Dry",
      "acidity": "Medium",
      "tannin": "High",
      "body": "Full"
    },
    "alcolVolume": "13%",
    "priceRange": "$$$"
  },
  // Additional pairings...
]
```

The response is streamed and varies in size based on the generated content. On the client side, you should process the stream accordingly.

#### Handling the Readable Stream Response (JavaScript Example)
To handle the Readable Stream response in JavaScript, you can use the following code as an example:

```javascript
const responseStream = fetch('/api/generate/stream/pairings', {
  method: 'POST',
  headers: {
    'Authorization': 'YOUR_API_KEY',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
  "drinkType": "wine",
  "meal": "Grilled Salmon"
}
),
});

// Process the stream
responseStream.then(async (response) => {
  const reader = response.body.getReader();
  const decoder = new TextDecoder();

  while (!done) {
      const { value, done: doneReading } = await reader.read();

      done = doneReading; // Break the loop if stream completed
      const newValue = decoder.decode(value);
      chunks = chunks + newValue;
    }

    // Parses the completed response (pairings data)
    const pairingsData = JSON.parse(chunks);

    // Handle the pairings data as needed
    console.log(pairingsData);

});
```

## Execution Time

As responses are generated on the fly through AI, response time will vary depending on the lenght of the response. Approximate time for response is 15s for the 'pairings' endpoint.

## Error Responses

Both routes return specific error responses for various scenarios:

- **Missing API Key (Status Code: 403)**:
  - Response: `No API Key in request`
- **Invalid API Key (Status Code: 403)**:
  - Response: `Invalid API Key`
- **Missing Required Inputs (Status Code: 400)**:
  - Response: `Required inputs not provided`
- **Inactive Subscription (Status Code: 403)**:
  - Response: `You don't have an active subscription`

The 'pairings' endpoint allows you to generate beverage pairings that go well with a given meal. Customers have the choice of receiving the response as JSON or as a readable stream.

Pairings


## Introduction

This API route allows you to generate a personalized meal plan based on specific criteria and constraints. It provides two endpoints, each with a different response format:

- **JSON Route**: Returns the Meal Plan details as JSON.
- **Readable Stream Route**: Streams the Meal Plan details in a readable stream.

## Authentication

To access these endpoints, you must include an `Authorization` header with a valid API key.

## Common Request Parameters

Both routes accept the following request parameters:

- `goal` (enum, required): The meal plan goal, ['lose-weight', 'gain-muscles', 'eat-healthy']
- `duration` (number, required): The number of days for the meal plan.
- `activityLevel` (enum, required): The user's daily activity level ['sedentary', 'light-active', 'moderately-active', 'very-active', 'extremely-active'].
- `age` (number, required): The user's age.
- `height` (number, required): The user's height in centimeters.
- `weight` (number, required): The user's weight in kilograms.
- `gender` (string, required): The user's gender ['male', 'female', 'undefined']
- `diet` (string, required): The dietary preference ['vegetarian','pescatarian','vegan','diaryfree','glutenfree','keto','paleo'].
- `measurement` (string, required): The measurement system used in the output ['imperial', 'metric']. Default: Metric.


## JSON Route Details

### Endpoint

`POST /api/generate/meal-plan`

### Request Example

```json
POST /api/generate/meal-plan
Headers:
{
  "Authorization": "YOUR_API_KEY"
}
Body:
{
  "goal": "lose-weight",
  "duration": 30,
  "activityLevel": "moderately-active",
  "age": 30,
  "height": 175,
  "weight": 70,
  "gender": "male",
  "diet": "vegetarian"
}
```

### Response (JSON)

- **Status Code:** 200 (OK)
- **Content-Type:** application/json

```json
{
  "mealPlan": [
    {
      "day": 1,
      "breakfast": {
        "recipeName": "Healthy Oatmeal",
        "difficulty": "novice",
        "kitchenToolsUsed": ["bowl", "spoon"],
        "instructions": ["Cook oats with water.", "Add fruits and nuts.", "Enjoy!"],
        "preparationTime": 15,
        "servings": 1,
        "ingredients": [
          {
            "name": "Oats",
            "unit": "grams",
            "amount": 50
          },
          {
            "name": "Banana",
            "unit": "pieces",
            "amount": 1
          },
          {
            "name": "Almonds",
            "unit": "grams",
            "amount": 20
          }
        ],
        "macros": {
          "carbs": {
            "amount": 30,
            "unit": "grams"
          },
          "fats": {
            "amount": 10,
            "unit": "grams"
          },
          "proteins": {
            "amount": 5,
            "unit": "grams"
          },
          "calories": {
            "amount": 250,
            "unit": "kcal"
          }
        }
      },
      "lunch": {
        // ... (same structure as breakfast)
      },
      "snack": {
        // ... (same structure as breakfast)
      },
      "dinner": {
        // ... (same structure as breakfast)
      }
    },
    // ... (meal plan for other days)
  ]
}

```

## Readable Stream Route Details

### Endpoint

`POST /api/generate/stream/meal-plan`

### Request Example

```json
POST /api/generate/stream/meal-plan
Headers:
{
  "Authorization": "YOUR_API_KEY"
}
Body:
{
  "goal": "lose-weight",
  "duration": 30,
  "activityLevel": "moderately-active",
  "age": 30,
  "height": 175,
  "weight": 70,
  "gender": "male",
  "diet": "vegetarian"
}
```

### Response (Readable Stream)

- **Status Code:** 200 (OK)
- **Content-Type:** application/json (Streaming)

```json
{
  "mealPlan": [
    {
      "day": 1,
      "breakfast": {
        "recipeName": "Healthy Oatmeal",
        "difficulty": "novice",
        "kitchenToolsUsed": ["bowl", "spoon"],
        "instructions": ["Cook oats with water.", "Add fruits and nuts.", "Enjoy!"],
        "preparationTime": 15,
        "servings": 1,
        "ingredients": [
          {
            "name": "Oats",
            "unit": "grams",
            "amount": 50
          },
          {
            "name": "Banana",
            "unit": "pieces",
            "amount": 1
          },
          {
            "name": "Almonds",
            "unit": "grams",
            "amount": 20
          }
        ],
        "macros": {
          "carbs": {
            "amount": 30,
            "unit": "grams"
          },
          "fats": {
            "amount": 10,
            "unit": "grams"
          },
          "proteins": {
            "amount": 5,
            "unit": "grams"
          },
          "calories": {
            "amount": 250,
            "unit": "kcal"
          }
        }
      },
      "lunch": {
        // ... (same structure as breakfast)
      },
      "snack": {
        // ... (same structure as breakfast)
      },
      "dinner": {
        // ... (same structure as breakfast)
      }
    },
    // ... (meal plan for other days)
  ]
}

```

The response is streamed and varies in size based on the generated content. On the client side, you should process the stream accordingly.

#### Handling the Readable Stream Response (JavaScript Example)
To handle the Readable Stream response in JavaScript, you can use the following code as an example:

```javascript
const responseStream = fetch('/api/generate/stream/meal-plan', {
  method: 'POST',
  headers: {
    'Authorization': 'YOUR_API_KEY',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
  "goal": "lose-weight",
  "duration": 30,
  "activityLevel": "moderately-active",
  "age": 30,
  "height": 175,
  "weight": 70,
  "gender": "male",
  "diet": "vegetarian"
}),
});

// Process the stream
responseStream.then(async (response) => {
  const reader = response.body.getReader();
  const decoder = new TextDecoder();

  let done
  let chunks

  while (!done) {
      const { value, done: doneReading } = await reader.read();

      done = doneReading; // Break the loop if stream completed
      const newValue = decoder.decode(value);
      chunks = chunks + newValue;
    }

    // Parses the completed response (mealPlan data)
    const mealPlanData = JSON.parse(chunks);

    // Handle the mealPlan data as needed
    console.log(mealPlanData);

});
```

## Execution Time

As responses are generated on the fly through AI, response time will vary depending on the lenght of the response. Approximate time for response is 10s per recipe. A 'meal-plan' endpoint response is composed by multiple days and each days is composed by 4 recipes, you should account for a response time of 40/45 seconds per day.
We strongly recommend using the Readable Stream endpoint for meal-plan as it will benefit your end-user experience.

## Error Responses

Both routes return specific error responses for various scenarios:

- **Missing API Key (Status Code: 403)**:
  - Response: `No API Key in request`
- **Invalid API Key (Status Code: 403)**:
  - Response: `Invalid API Key`
- **Missing Required Inputs (Status Code: 400)**:
  - Response: `Required inputs not provided`
- **Inactive Subscription (Status Code: 403)**:
  - Response: `You don't have an active subscription`

The 'meal-plan' endpoint allows you to generate a personalized meal plan based on specific criteria and constraints. Customers have the choice of receiving the response as JSON or as a readable stream.

Meal Plan

Widgets


The widget feature in allows you to create and customize various types of widgets powered by ChefGPT API that can be embedded in your website or application. With widgets, you can go live with ChefGPT API in a matter of minutes. This documentation will guide you through the process of creating and implementing a widget in your app.

## Creating a Widget

To create a widget, follow these steps:

- Access the Widget Editor: Navigate to the [Widget Editor section](api.chefgpt.xyz/widgets).
- Create an Widget: Click on "Create New Widget" button.
- Name your Widget: Give your widget a name so you can easily reference back to it.
- Choose Widget Type: Select the type of widget you want to create from the available options, such as Recipe From Ingredients, Recipe From Macros, Pairings, or Meal Plan.
- Save Your Widget: Once you are satisfied with the selection, save your widget to finalize the creation process.

Newly created widgets are set as "Inactive" by default. To activate the widget, access the widget configuration by clicking on the "Edit" button of the newly created widget.

Learn how to create Widgets powered by ChefGPT API.

How to Create a Widget


## Activating a Widget

To Activate a widget, follow these steps:

- Access the Widget Editor: Navigate to the [Widget Editor section](api.chefgpt.xyz/widgets).
- Locate the Widget: Find the widget you want to update or delete from the list of created widgets.
- Turn on the Active control: To activate the widget turn on the "Active" toggle in the widget configuration.
- Save Changes: If you are satisfied with your changes, click on the Save Changes button.

Note: The pre-requisite for a widget to work correctly is having an active API Key. If you delete your API Key your widgets will stop working even if they are set as "Active".


How to Activate a Widget


## Customizing a Widget

To Customize a widget, follow these steps:

- Access the Widget Editor: Navigate to the [Widget Editor section](api.chefgpt.xyz/widgets).
- Locate the Widget: Find the widget you want to update from the list of created widgets.
- Access the Widget Configuration: Click on the "Edit" button.
- Update Widget Configuration: To update the widget configuration, make the desired changes using the provided interface and save the updated configuration.
- Save Changes: If you are satisfied with your changes, click on the Save Changes button.

## FAQ

- Can I remove a field from the widget? No, you cannot remove any field of each widget.
- Can I completely change a field? No, you can only change the question text/label. Changes will not affect the information captured by the widget. These type of customization are meant for you to tweak the wording or to translate the widget to another language.
- Can I change the language output of the widget? No, It's not possible at the moment.
- Can I remove the lable "Powered by ChefGPT"? Only Pro Subscription plans and above can remove the label.





How to Customize a Widget


Adter you have activated and customized your widget to your preference you can proceed with implementation in your website or app.

## Implementing a Widget

To Implement a widget, follow these steps:

- Access the Widget Editor: Navigate to the [Widget Editor section](api.chefgpt.xyz/widgets).
- Locate the Widget: Find the widget you want to implement from the list of created widgets.
- Retreive the Widget Embed Code: Click on the "Embed" button.
- Implement the Widget: To Implement the widget copy the embed code from the menu and paste it in your app or website code.

The embed code is provided in iframe format only. You are free to customize the iframe appearance using the style parameters as you prefer.


How to Implement a Widget


## Deleting a Widget

To Delete a widget, follow these steps:

- Access the Widget Editor: Navigate to the [Widget Editor section](api.chefgpt.xyz/widgets).
- Locate the Widget: Find the widget you want to delete from the list of created widgets.
- Access the Widget Configuration: Click on the "Edit" button.
- Delete the Widget: To Delete the widget click on the "Delete Widget" button.

Note: When you delete a widget in your ChefGPT API console, the widget will stop working anywhere on the internet where it was previously embedded.


How to Delete a Widget

Changelogs


## Release Date: September 9, 2023

We are excited to announce the initial release of our API, version 1.0. In this inaugural version, there are no changes to report as it marks the starting point of our API's journey.

**Key Highlights:**

- Version: 1.0
- Release Date: September 30, 2023
- No Changes: This release establishes the foundation of our API, and no modifications or updates have been made since its inception.

We are committed to providing you with a stable and reliable API to enhance your application's capabilities. Stay tuned for future updates and enhancements as we continue to evolve and improve our API.

If you have any questions or require assistance, please don't hesitate to reach out to our support team.

Thank you for choosing our API, and we look forward to serving your needs in the future!

---

Version 1.0 (Initial Release)


## Release Date: October 23, 2023

**Key Highlights:**

- Version: 1.1
- Release Date: October 23, 2023
- Added support to Imperial and Metric measurement systems.

With this update we have added a new optional parameter to our endpoints to allow you to set what measurement system you want the system to use (Imperial or Metric).
By default, the system will use the Metric system.

If you have any questions or require assistance, please don't hesitate to reach out to our support team.

---

Documentation

Explore our guides and examples to integrate ChefGPT API in your app.

Introduction

API Key

Endpoints

Widgets

Changelogs

Introduction

API Key

Endpoints

Widgets

Changelogs