Unified GUI Censorship Resistant Solution Powered by Xray

English / فارسی / 简体中文 / Русский

• Overview
  • Why using Rebecca?
    • Features
• Installation guide
• Configuration
• Documentation
• API
• Backup
• Telegram Bot
• Rebecca CLI
• Rebecca Node
• Webhook notifications
• Donation
• License
• Contributors

Rebecca is a proxy management tool that provides a simple and easy-to-use user interface for managing hundreds of proxy accounts powered by Xray-core and built using Python and React.

Rebecca is user-friendly, feature-rich and reliable. It lets you create different proxies for your users without any complicated configuration. Using its built-in web UI, you can monitor, modify and limit users.

• Built-in Web UI
• Fully REST API backend
• Multiple Nodes support (for infrastructure distribution & scalability)
• Supports protocols Vmess, VLESS, Trojan and Shadowsocks
• Multi-protocol for a single user
• Multi-user on a single inbound
• Multi-inbound on a single port (fallbacks support)
• Traffic and expiry date limitations
• Periodic traffic limit (e.g. daily, weekly, etc.)
• Subscription link compatible with V2ray (such as V2RayNG, SingBox, Nekoray, etc.), Clash and ClashMeta
• Automated Share link and QRcode generator
• System monitoring and traffic statistics
• Customizable xray configuration
• TLS and REALITY support
• Integrated Telegram Bot
• Integrated Command Line Interface (CLI)
• Multi-language
• Multi-admin support (WIP)

Run the following command to install Rebecca with SQLite database:

sudo bash -c "$(curl -sL https://github.com/rebeccapanel/Rebecca-scripts/raw/master/rebecca.sh)" @ install

Run the following command to install Rebecca with MySQL database:

sudo bash -c "$(curl -sL https://github.com/rebeccapanel/Rebecca-scripts/raw/master/rebecca.sh)" @ install --database mysql

Run the following command to install Rebecca with MariaDB database:

sudo bash -c "$(curl -sL https://github.com/rebeccapanel/Rebecca-scripts/raw/master/rebecca.sh)" @ install --database mariadb

Once the installation is complete:

• You will see the logs that you can stop watching them by closing the terminal or pressing Ctrl+C
• The Rebecca files will be located at /opt/rebecca
• The configuration file can be found at /opt/rebecca/.env (refer to configurations section to see variables)
• The data files will be placed at /var/lib/rebecca
• For security reasons, the Rebecca dashboard is not accessible via IP address. Therefore, you must obtain an SSL certificate and access your Rebecca dashboard by opening a web browser and navigating to https://YOUR_DOMAIN:8000/dashboard/ (replace YOUR_DOMAIN with your actual domain)
• You can also use SSH port forwarding to access the Rebecca dashboard locally without a domain. Replace user@serverip with your actual SSH username and server IP and Run the command below:

ssh -L 8000:localhost:8000 user@serverip

Finally, you can enter the following link in your browser to access your Rebecca dashboard:

http://localhost:8000/dashboard/

You will lose access to the dashboard as soon as you close the SSH terminal. Therefore, this method is recommended only for testing purposes.

Next, you need to create a sudo admin for logging into the Rebecca dashboard by the following command

rebecca cli admin create --role full_access

That's it! You can login to your dashboard using these credentials

Full access admins can only be created by another full access admin from the dashboard or by using the on-box rebecca cli.
If you ever need to promote an existing sudo admin, run
rebecca cli admin change-role --username YOUR_ADMIN --role full_access

To see the help message of the Rebecca script, run the following command

rebecca --help

If you are eager to run the project using the source code, check the section below

bash -c "$(curl -L https://github.com/XTLS/Xray-install/raw/main/install-release.sh)" @ install

git clone https://github.com/rebeccapanel/Rebecca.git
cd Rebecca
wget -qO- https://bootstrap.pypa.io/get-pip.py | python3 -
python3 -m pip install -r requirements.txt

alembic upgrade head

sudo ln -s $(pwd)/rebecca-cli.py /usr/bin/rebecca-cli
sudo chmod +x /usr/bin/rebecca-cli
rebecca-cli completion install

cp .env.example .env
nano .env

python3 main.py

systemctl enable /var/lib/rebecca/rebecca.service
systemctl start rebecca

server {
    listen 443 ssl http2;
    listen [::]:443 ssl http2;
    server_name  example.com;

    ssl_certificate      /etc/letsencrypt/live/example.com/fullchain.pem;
    ssl_certificate_key  /etc/letsencrypt/live/example.com/privkey.pem;

    location ~* /(dashboard|statics|sub|api|docs|redoc|openapi.json) {
        proxy_pass http://0.0.0.0:8000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }

  # xray-core ws-path: /
  # client ws-path: /rebecca/me/2087
    #
  # All traffic is proxied through port 443, and sent to the xray port (2087, 2088, etc.).
  # The '/rebecca' in the location regex path can be changed to any value you like.
    #
  # /${path}/${username}/${xray-port}
  location ~* /rebecca/.+/(.+)$ {
        proxy_redirect off;
        proxy_pass http://127.0.0.1:$1/;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_set_header Host $http_host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }
}

server {
    listen 443 ssl http2;
    listen [::]:443 ssl http2;
  server_name  rebecca.example.com;

    ssl_certificate      /etc/letsencrypt/live/example.com/fullchain.pem;
    ssl_certificate_key  /etc/letsencrypt/live/example.com/privkey.pem;

    location / {
        proxy_pass http://0.0.0.0:8000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }
}

You can set settings below using environment variables or placing them in .env file.

Rebecca documentation is a work in progress. We welcome and appreciate your contributions to help us improve it. Please open issues or PRs in the main repository.

Rebecca provides a REST API that enables developers to interact with its services programmatically. To view the API documentation in Swagger UI or ReDoc, set the configuration variable DOCS=True and navigate to /docs and /redoc.

It's always a good idea to back up your Rebecca files regularly to prevent data loss in case of system failures or accidental deletion. Here are the steps to back up Rebecca:

1. By default, all Rebecca important files are saved in /var/lib/rebecca (Docker versions). Copy the entire /var/lib/rebecca directory to a backup location of your choice, such as an external hard drive or cloud storage.
2. Additionally, make sure to back up your env file, which contains your configuration variables, and also your Xray config file. If you installed Rebecca using rebecca-scripts (recommended installation approach), the env and other configurations should be inside the /opt/rebecca/ directory.

Rebecca's backup service efficiently zips all necessary files and sends them to your specified Telegram bot. It supports SQLite, MySQL, and MariaDB databases. One of its key features is automation, allowing you to schedule backups every hour. There are no limitations concerning Telegram's upload limits for bots; if a file exceeds the limit, it will be split and sent in multiple parts. Additionally, you can initiate an immediate backup at any time.

Install the Latest Version of Rebecca Command:

sudo bash -c "$(curl -sL https://github.com/rebeccapanel/Rebecca-scripts/raw/master/rebecca.sh)" @ install-script

Setup the Backup Service:

rebecca backup-service

Get an Immediate Backup:

rebecca backup

By following these steps, you can ensure that you have a backup of all your Rebecca files and data, as well as your configuration variables and Xray configuration, in case you need to restore them in the future. Remember to update your backups regularly to keep them up-to-date.

Rebecca comes with an integrated Telegram bot that can handle server management, user creation and removal, and send notifications. This bot can be easily enabled by following a few simple steps, and it provides a convenient way to interact with Rebecca without having to log in to the server every time.

To enable Telegram Bot:

1. set TELEGRAM_API_TOKEN to your bot's API Token
2. set TELEGRAM_ADMIN_ID to your Telegram account's numeric ID, you can get your ID from @userinfobot

Rebecca comes with an integrated CLI which allows administrators to have direct interaction with it.

If you've installed Rebecca using the easy install script, you can access the CLI commands by running

rebecca cli [OPTIONS] COMMAND [ARGS]...

For more information, you can read the CLI documentation in ./cli/README.md.

The Rebecca project introduces the Rebecca-node, which enables infrastructure distribution. With Rebecca-node, you can distribute your infrastructure across multiple locations, unlocking benefits such as redundancy, high availability, scalability, and flexibility. Rebecca-node empowers users to connect to different servers, offering them the flexibility to choose and connect to multiple servers instead of being limited to only one server. For more detailed information and installation instructions, please refer to the Rebecca-node repository.

You can set a webhook address and Rebecca will send the notifications to that address.

the requests will be sent as a post request to the adress provided by WEBHOOK_ADDRESS with WEBHOOK_SECRET as x-webhook-secret in the headers.

Example request sent from Rebecca:

Headers:
Host: 0.0.0.0:9000
User-Agent: python-requests/2.28.1
Accept-Encoding: gzip, deflate
Accept: */*
Connection: keep-alive
x-webhook-secret: something-very-very-secret
Content-Length: 107
Content-Type: application/json



Body:
{"username": "rebecca_test_user", "action": "user_updated", "enqueued_at": 1680506457.636369, "tries": 0}

Different action typs are: user_created, user_updated, user_deleted, user_limited, user_expired, user_disabled, user_enabled

If you found Rebecca useful and would like to support its development, you can make a donation in one of the following crypto networks:

• TRON network (TRC20): TGftLESDAeRncE7yMAHrTUCsixuUwPc6qp
• ETH, BNB, MATIC network (ERC20, BEP20): 0x413eb47C430a3eb0E4262f267C1AE020E0C7F84D
• TON network: UQDNpA3SlFMorlrCJJcqQjix93ijJfhAwIxnbTwZTLiHZ0Xa

Thank you for your support!

Made in [Unknown!] and published under AGPL-3.0.

We ❤️‍🔥 contributors! If you'd like to contribute, please check out our Contributing Guidelines and feel free to submit a pull request or open an issue.

Check open issues to help the progress of this project.

Thanks to the all contributors who have helped improve Rebecca:

Made with contrib.rocks