---
title: "Deploy StakeVladDracula - AI API Proxy Service"
description: "Pure AI API Proxy Service - No UI, Just Performance"
category: "Other"
url: https://railway.com/deploy/stakevladdracula
---

# Deploy StakeVladDracula - AI API Proxy Service

Pure AI API Proxy Service - No UI, Just Performance

**[Deploy StakeVladDracula - AI API Proxy Service on Railway](https://railway.com/template/stakevladdracula)**

- **Creator:** Muhammad Bilal
- **Category:** Other

## Template content

### StakeVladDracula

- **Source:** Herm-Studio/StakeVladDracula
- **Public domain:** Yes

## Documentation

# Deploy and Host Stake Vlad Dracula on Railway

StakeVladDracula is a pure AI API proxy service that routes requests to multiple AI providers through a unified API endpoint. It supports OpenAI, OpenAI Responses API, Claude, Gemini, and Groq. The service has no frontend UI and is designed for API integrations, routing requests through a single deployed endpoint.

## About Hosting Stake Vlad Dracula

Hosting StakeVladDracula on Railway involves deploying the `main` branch of the GitHub repository as a Railway service. The documented Railway configuration uses the Docker runtime and exposes the application's HTTP service on port `80`. The application binds to `0.0.0.0` so it can receive traffic through Railway's network. Railway provides the public HTTPS domain used to access the API proxy, while `SERVER_NAME` is configured using the Railway public domain. No database or persistent storage is documented as required. After deployment, applications can use the Railway URL as their API base URL for supported OpenAI, Claude, Gemini, and Groq integrations.

## Common Use Cases

* Provide a unified API proxy for multiple AI providers.
* Route OpenAI, Claude, Gemini, and Groq API requests through a single endpoint.
* Integrate AI APIs into applications using a self-hosted API proxy.

## Dependencies for Stake Vlad Dracula Hosting

* GitHub repository containing the StakeVladDracula application.
* API credentials for the AI provider being used.

### Deployment Dependencies

* [StakeVladDracula GitHub Repository](https://github.com/Herm-Studio/StakeVladDracula)
* [OpenAI API](https://platform.openai.com/)
* [Anthropic API](https://www.anthropic.com/api)
* [Google Gemini API](https://ai.google.dev/)
* [Groq API](https://console.groq.com/)

### Implementation Details

#### Deployment Source

Deploy the application from the following GitHub repository:

```text
https://github.com/Herm-Studio/StakeVladDracula
```

Use the:

```text
main
```

branch.

The supplied deployment configuration does not document a Dockerfile or a custom Docker image for this repository. Railway should therefore use the repository as the deployment source with the documented Docker runtime setting.

#### Public Networking

The application listens on port `80` and binds to all interfaces.

| Protocol | Proxy Type | Target Port | Purpose                              |
| -------- | ---------- | ----------: | ------------------------------------ |
| HTTP     | HTTP Proxy |          80 | AI API proxy and service information |

After deployment, open the Railway service and go to:

**Settings → Networking → Generate Domain**

Railway will provide a public HTTPS domain for the service.

#### Environment Variables

Configure the following variables in Railway:

| Variable              | Required | Description                                                 |
| --------------------- | -------- | ----------------------------------------------------------- |
| `FORCE_CONTAINERIZED` | Yes      | Forces the deployment to run in a containerized environment |
| `SERVER_NAME`         | Yes      | Public hostname used by the Nginx configuration             |

Raw Editor example:

```env
FORCE_CONTAINERIZED=1
SERVER_NAME=${{RAILWAY_PUBLIC_DOMAIN}}
```

The `SERVER_NAME` value uses Railway's public domain reference so the application can use the generated hostname.

No AI provider API keys are documented as Railway environment variables. Provider credentials are supplied with requests from the client application.

#### Persistent Storage

Persistent storage is not documented as required for StakeVladDracula.

No Railway Volume is required.

#### Database

No database is required by the documented deployment configuration.

#### Build & Start

The supplied deployment information does not document custom build or start commands.

The Railway service is configured to use the Docker runtime, but no Dockerfile or custom Docker image is documented in the supplied repository deployment information.

#### Accessing the Application

After deployment:

1. Open the StakeVladDracula service in Railway.
2. Go to **Settings → Networking**.
3. Generate a Railway domain for port `80`.
4. Open the generated HTTPS URL.
5. Use the generated URL as the base URL for API requests.

The root endpoint provides API information and available endpoints.

Use the following placeholder throughout the examples:

```text
https://
```

### How to Use

Once the project is deployed, use the generated Railway domain as the base URL for your AI provider requests.

Replace:

```text

```

with the public domain generated by Railway.

### OpenAI

For OpenAI-compatible requests, change the OpenAI `baseURL` from:

```text
https://api.openai.com/v1
```

to:

```text
https:///v1
```

For example:

```javascript
import OpenAI from 'openai';

const openai = new OpenAI({
  apiKey: 'YOUR_OPENAI_API_KEY',
  baseURL: 'https:///v1',
});
```

A standard OpenAI chat completion request uses:

```text
https:///v1/chat/completions
```

The OpenAI API key should be provided by your application as usual.

### OpenAI Responses API

StakeVladDracula v2.0 also supports the OpenAI Responses API.

Use:

```text
https:///v1/responses
```

For example:

```bash
curl https:///v1/responses/create \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_OPENAI_API_KEY" \
  -d '{
    "model": "gpt-4",
    "messages": [
      {
        "role": "user",
        "content": "Hello!"
      }
    ],
    "response_format": {
      "type": "json_object"
    }
  }'
```

The documented Responses API route is:

```text
/v1/responses/*
```

### Gemini

For Gemini, change the standard Gemini API base URL:

```text
https://generativelanguage.googleapis.com/v1beta
```

to:

```text
https:///v1beta
```

For example:

```bash
export API_KEY="YOUR_GEMINI_API_KEY"
export BASE_URL="https:///v1beta"

curl https://${BASE_URL}/models/gemini-pro:generateContent?key=${API_KEY} \
    -H 'Content-Type: application/json' \
    -X POST \
    -d '{
      "contents": [{
        "parts": [{
          "text": "Write a story about a magic backpack."
        }]
      }]
    }'
```

The documented Gemini route is:

```text
/v1beta/*
```

### Groq

For Groq, change the standard Groq OpenAI-compatible API base URL:

```text
https://api.groq.com/openai/v1
```

to:

```text
https:///openai/v1
```

For example:

```bash
export API_KEY="YOUR_GROQ_API_KEY"
export BASE_URL="https:///openai/v1"

curl https://${BASE_URL}/chat/completions \
    -H "Authorization: Bearer $GROQ_API_KEY" \
    -H 'Content-Type: application/json' \
    -X POST \
    -d '{
      "messages": [
        {
          "role": "user",
          "content": "Explain the importance of low latency LLMs"
        }
      ],
      "model": "mixtral-8x7b-32768"
    }'
```

The documented Groq route is:

```text
/openai/v1/*
```

### Claude

For Claude, change the standard Anthropic API base URL:

```text
https://api.anthropic.com/v1
```

to:

```text
https:///v1
```

For example:

```bash
export API_KEY="YOUR_ANTHROPIC_API_KEY"
export BASE_URL="https:///v1"

curl https://${BASE_URL}/v1/messages \
     --header "x-api-key: $ANTHROPIC_API_KEY" \
     --header "anthropic-version: 2023-06-01" \
     --header "content-type: application/json" \
     --data \
      '{
        "model": "claude-3-opus-20240229",
        "max_tokens": 1024,
        "messages": [
          {
            "role": "user",
            "content": "Hello, world"
          }
        ]
      }'
```

The documented Claude route is:

```text
/v1/messages/*
```

### API Endpoint Summary

| Provider         | Base URL                                     | Example Endpoint                            |
| ---------------- | -------------------------------------------- | ------------------------------------------- |
| OpenAI           | `https:///v1`           | `/v1/chat/completions`                      |
| OpenAI Responses | `https:///v1/responses` | `/v1/responses/create`                      |
| Claude           | `https:///v1`           | `/v1/messages`                              |
| Gemini           | `https:///v1beta`       | `/v1beta/models/gemini-pro:generateContent` |
| Groq             | `https:///openai/v1`    | `/openai/v1/chat/completions`               |

### Router Information

All requests processed by StakeVladDracula include the following identification header:

```text
StakeVladDracula-Router: v2.0
```

This identifies requests processed by Router v2.0 and can be used for debugging.

The documented v2.0 release added OpenAI Responses API support and changed the project to a pure API service architecture.

The project documentation describes StakeVladDracula as experimental and recommends caution when using it.

## Why Deploy Stake Vlad Dracula on Railway?

Railway is a singular platform to deploy your infrastructure stack. Railway will host your infrastructure so you don't have to deal with configuration, while allowing you to vertically and horizontally scale it.

By deploying Stake Vlad Dracula on Railway, you are one step closer to supporting a complete full-stack application with minimal burden. Host your servers, databases, AI agents, and more on Railway.


## Similar templates

- [Rocky Linux](https://railway.com/deploy/rocky-linux) — [Jul'26] Hosted Rocky Linux 9 workspace with SSH and persistent storage. 🚀
- [Foundry Virtual Tabletop](https://railway.com/deploy/X5tR6G) — A Self-Hosted & Modern Roleplaying Platform
- [Letta Code Remote](https://railway.com/deploy/letta-code-remote) — Run a Letta Code agent 24/7. No inbound ports, just deploy.

Open this page in a browser: https://railway.com/deploy/stakevladdracula