# Direct Docs Queries

Here are the answers to your questions based on the documentation from [Redocly](https://redocly.com/docs). I’ve addressed each query with the relevant information and provided guidance on how to achieve your goals using Redocly’s tools and configurations.

### 1. How do I protect `debrief.md` so that it requires someone with the “pearl” role to access it?

To protect a specific page like `debrief.md` and restrict access to users with a particular role such as “pearl,” you can use Redocly’s role-based access control (RBAC) features. According to the Redocly documentation, you can configure access control in your project settings or through a custom authentication setup.

- **Step 1: Define Roles in Authentication Configuration**
If you’re using a custom authentication provider (e.g., OAuth, OpenID Connect), ensure that the “pearl” role is defined in your identity provider and passed as a claim in the authentication token.
- **Step 2: Restrict Access in Redocly Configuration**
Use Redocly’s configuration file (e.g., `redocly.yaml`) to set up access rules. You can specify roles for specific paths or pages. For example:



```yaml
authorization:
  enabled: true
  policies:
    - path: /debrief.md
      roles: [“pearl”]
```

This configuration ensures that only users with the “pearl” role can access the `debrief.md` page.

- **Step 3: Enable Authentication**
Make sure authentication is enabled in your Redocly project. Refer to the [Authentication and Authorization](https://redocly.com/docs/developer-portal/authentication/) section of the documentation for detailed setup instructions.


If you’re using Redocly Developer Portal, you might also need to integrate with an identity provider and map roles accordingly. If this feature isn’t directly supported for Markdown files, consider hosting sensitive content behind a protected API endpoint or using a custom middleware to enforce role checks.

### 2. How do I create a code walkthrough?

Redocly supports creating code walkthroughs or tutorials as part of your documentation, especially for API guides or developer portals. Here’s how you can create a code walkthrough:

- **Step 1: Use Markdown or OpenAPI Descriptions**
You can write a step-by-step guide in Markdown or within your OpenAPI specification. Redocly renders Markdown files beautifully and supports rich formatting for code snippets.
- **Step 2: Add Code Examples**
Include code snippets with proper syntax highlighting. For example, in a Markdown file:



```markdown
## Code Walkthrough: Making an API Request

Follow these steps to make a request to our API:

1. **Install Dependencies**  
   ```bash
   npm install axios
```

1. **Make a Request**

```javascript
const axios = require(‘axios’);
axios.get(‘https://api.example.com/data’)
  .then(response => console.log(response.data))
  .catch(error => console.error(error));
```



```

-  **Step 3: Use Interactive Elements (Try It Console)**  
If your walkthrough involves API calls, link it to an OpenAPI definition and enable the “Try It” console in Redocly. This allows users to interact with the API directly from the documentation. Configure this in your `redocly.yaml`:
```yaml
apiDefinitions:
  main: openapi.yaml
features.openapi:
  tryIt: true
```

- **Step 4: Publish to Developer Portal**
Host the walkthrough in your Redocly Developer Portal for a polished look. Refer to the [Content Creation](https://redocly.com/docs/developer-portal/content/) guide for more details on structuring tutorials.


### 3. How do I only show the mock server in the Try It console (not a real server)?

To display only a mock server in the “Try It” console and prevent users from interacting with a real server, you can configure the server settings in your OpenAPI definition or Redocly configuration.

- **Step 1: Define a Mock Server in OpenAPI**
In your `openapi.yaml` file, specify a mock server URL. Redocly supports mock servers out of the box for testing purposes. For example:



```yaml
servers:
  - url: https://api.example.com/mock
    description: Mock Server
```

- **Step 2: Disable Real Server Access**
Ensure that no production or real server URLs are listed in the `servers` section of your OpenAPI definition, or explicitly mark them as non-interactive in Redocly’s configuration if needed.
- **Step 3: Enable Try It Console with Mocking**
In your `redocly.yaml`, enable the “Try It” feature and configure it to use mock responses if necessary:



```yaml
features.openapi:
  tryIt: true
  mockServer: true
```

Redocly can generate mock responses based on your OpenAPI schemas if a real endpoint isn’t available.

Refer to the [Try It Console](https://redocly.com/docs/api-reference-docs/try-it-console/) documentation for more details on configuring mock servers.

### 4. How do I run API monitoring using Redocly on a regular schedule?

Redocly does not directly provide built-in API monitoring tools for scheduled checks as part of its core documentation platform. However, you can achieve API monitoring using Redocly’s CLI or integrations with third-party tools.

- **Option 1: Use Redocly CLI for Validation**
Use the Redocly CLI to validate your API definitions or test endpoints periodically. You can script this process and run it on a schedule using a cron job or similar scheduling tool:



```bash
redocly lint openapi.yaml
```

Schedule this command to run at regular intervals using a cron job (e.g., every day at midnight):


```
0 0 * * * redocly lint openapi.yaml >> monitoring.log
```

- **Option 2: Integrate with Third-Party Monitoring Tools**
Redocly can be part of a broader CI/CD pipeline or monitoring setup. Integrate with tools like Postman, Newman, or custom scripts to test API endpoints and use Redocly to document the results or schemas. Check the [CLI Documentation](https://redocly.com/docs/cli/) for automation capabilities.
- **Option 3: Redocly Workflows (Enterprise Feature)**
If you have access to Redocly’s enterprise features, explore Redocly Workflows for automated API governance and monitoring. Contact Redocly support or refer to the [Enterprise Documentation](https://redocly.com/docs/enterprise/) for more information on setting up scheduled monitoring.


If you’re looking for a specific monitoring feature, I recommend checking the latest Redocly updates or reaching out to their support team.

### 5. How do I make headings purple colored in Redocly?

Customizing the appearance of headings (e.g., making them purple) in Redocly involves using custom themes or CSS overrides, as Redocly allows for extensive customization of its rendering.

- **Step 1: Create a Custom Theme**
Redocly supports theming via a configuration file. In your `redocly.yaml`, define a custom theme:



```yaml
theme:
  colors:
    primary:
      main: ‘#800080’ # Purple color for headings or accents
```

While this primarily affects UI elements, some heading styles may inherit from the primary color.

- **Step 2: Use Custom CSS for Headings**
If the theme configuration doesn’t apply to Markdown headings, you can inject custom CSS. Add a custom CSS file or inline styles in your Redocly project. For example, create a `custom.css` file:



```css
h1, h2, h3, h4, h5, h6 {
  color: #800080; /* Purple */
}
```

Reference this file in your `redocly.yaml`:


```yaml
styles:
  - custom.css
```

- **Step 3: Apply to Developer Portal or API Docs**
Ensure the custom styles are applied to your rendered documentation or developer portal. Refer to the [Customization Guide](https://redocly.com/docs/developer-portal/customization/) for detailed instructions on theming and CSS overrides.


Note that CSS customization might be limited to specific Redocly plans or require hosting the documentation yourself if you’re using Redocly’s hosted solution.

If you have further questions or need additional assistance with any of these configurations, feel free to ask! I’m also triggering a web search to ensure I haven’t missed any recent updates or specific details in the Redocly documentation.

Below are answers to your questions based on the latest Redocly documentation and resources:

1. **Protecting debrief.md with “pearl” role access**: Redocly supports role-based access controls for developer portals. You can configure access controls to restrict the `debrief.md` page to users with the “pearl” role by setting up authentication (e.g., via Cognito) and defining roles in your Redocly Workflows or configuration. Specific steps may require custom setup in the API registry. [^1](https://redocly.com/docs-legacy/api-reference-docs/configuration/functionality) [^2](https://www.youtube.com/channel/UCxYbPjnpqmHCmwg9iWf7wtQ/videos)
2. **Creating a code walkthrough**: Redocly allows generating code samples automatically based on your API definition. To create a detailed code walkthrough, include examples in your OpenAPI definition and customize the display using the `theme` settings in the Redocly configuration file for enhanced documentation. [^3](https://redocly.com/docs-legacy/api-reference-docs/guides/generate-code-samples)
3. **Showing only mock server in Try It console**: You can configure the “Try it” console to use only the mock server by setting the `mockServer` option in the Redocly configuration file. Ensure no real server URL is specified, or override it to point exclusively to the mock server provided by Redocly. [^4](https://redocly.com/docs/cli/configuration) [^5](https://redocly.com/docs-legacy/api-reference-docs/guides/try-it-console)
4. **Running API monitoring on a schedule**: Redocly does not explicitly mention built-in scheduled API monitoring in the provided resources. You may need to use external tools or scripts in conjunction with Redocly CLI or API registry features to automate linting and monitoring tasks. Check Redocly Workflows for advanced automation options. [^6](https://redocly.com/docs-legacy/api-registry/guides/migration-guide-config-file)
5. **Making headings purple in Redocly**: Customize heading colors by modifying the `theme` object in the Redocly configuration file. Add CSS overrides or use the theme customization options to set heading styles (e.g., `color: purple`) under the typography or component settings for documentation. [^4](https://redocly.com/docs/cli/configuration) [^1](https://redocly.com/docs-legacy/api-reference-docs/configuration/functionality)