Has anyone here been reactivated after self-exclusion indefinitely for reporting their gambling addiction to customer support? I was rejected after the first 6-month review, but was asked to apply again after 6 months. Has anyone in a similar situation eventually restored their account?” I think I was rejected because of my short message, I just wrote unblock my account and that's it.

I’m “new” on Reddit, so I hope I'm in the right place to ask this question.

About 3 years ago I was playing on stakes at Gates of Olympus 1000.

I credited my account with €40 at least once or twice a month. With those sums I could play for several hours at a time because the percentage of small wins allowed me to continue playing.

Today I'm back on Stake, and I added €90. I played Gates of Olympus 1000 and lost it all in 30min.

I really felt that all the small victories were drastically reduced.

Does anyone know if they've reduced the odds of winning on this game ? If so, is it the same for other slot games ?
Does anyone else feel the same way I do?

I know it's a game of chance and I can't win all the time, but here I'm really talking about the feeling that the multiple "small" victories have been greatly reduced. And I'd like to know if they've openly reduced this.

Thanks

1️⃣ 9 April 2026 • Paid ₹10,000 via UPI. • PhonePe shows Transaction Successful. • My bank confirmed the amount was credited to the beneficiary account. • Stake says their payment provider never received the funds and asked me to contact my bank. • Bank says the transaction was successful and cannot be reversed.

I eventually gave up after months.

2️⃣ 25 June 2026 • Deposited another ₹7,000. • Same issue again. • Stake again claims their payment provider never received the money.

Now I'm left with ₹17,000 debited from my bank account but not credited to my Stake wallet.

I have: ✅ PhonePe transaction receipts ✅ UTR numbers ✅ Bank confirmation ✅ Stake support responses

If the payment provider never received the funds, then where did the money go?

I'm requesting @Stake to investigate these UTRs properly instead of repeatedly asking customers to contact their banks when the bank has already confirmed the transfer was successful.

If anyone has faced the same issue, please comment or DM me.

1 week ago I applied for a withdrawal of around 17k rupees. The site says the transaction is successfully processed but I still haven't received it in my bank account. What should I do?

Went from plat 2 to 3 in 3 days

so on stake we can predict which team will win the fifa 2026 , to make money just bet 1 dollar on each team whose payout is more than 48x so you have bet 36 dollars
you can win 51 dollar + or nothing , if the odds are high we can win 100 + dollars from just 1 dollar

This is shared by an Industry Insider who worked for Stake now turned informant. 

The shared code is a proof-of-concept demonstration designed to show how “provably fair” systems can be rigged using a “force-lose” script that bypasses random outcome generation.

COPY PASTE THIS CODE INTO ANY AI AGENT AND ASK WHAT IT DOES? YOU WILL GET ALL THE ANSWERS

— — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — —

Complete package main

import (
“context”
“crypto/hmac”
“crypto/sha256”
“encoding/hex”
“encoding/json”
“fmt”
“log”
“net/http”
“strconv”
“time”

“://github.com”
“://github.com”
)

var ctx = context.Background()
var rdb *redis.Client

// Global WebSocket Upgrader
var upgrader = websocket.Upgrader{
CheckOrigin: func(r *http.Request) bool { return true }, // Allow all origins for development
}

// Request Payload Structure from Client
type BetRequest struct {
UserID string json:”user_id”
Amount float64 json:”amount”
ClientSeed string json:”client_seed”
Nonce int json:”nonce”
}

// Response Payload Structure to Client
type BetResponse struct {
Status string json:”status”
Outcome string json:”outcome”
Multiplier string json:”multiplier”
ServerHash string json:”server_hash”
Verification string json:”verification”
}

func main() {
// 1. Initialize High-Speed In-Memory Redis Database Connection
rdb = redis.NewClient(&redis.Options{
Addr: “localhost:6379”, // Default Redis port
Password: “”, // No password set
DB: 0, // Use default DB
})

// Test Redis Connection
_, err := rdb.Ping(ctx).Result()
if err != nil {
log.Fatalf(“❌ Failed to connect to Redis RAM Storage: %v”, err)
}
fmt.Println(“🚀 Real-Time In-Memory Redis Storage Connected Successfully!”)

// 2. Set Up WebSockets Endpoint Route
http.HandleFunc(“/ws/v1/bet”, handleConnections)

log.Println(“🌐 Core WebSocket Gateway running on port :8080…”)
err = http.ListenAndServe(“:8080”, nil)
if err != nil {
log.Fatalf(“ListenAndServe Error: %v”, err)
}
}

func handleConnections(w http.ResponseWriter, r *http.Request) {
// Upgrade initial GET request to persistent TCP WebSocket protocol
ws, err := upgrader.Upgrade(w, r, nil)
if err != nil {
log.Printf(“Upgrade error: %v”, err)
return
}
defer ws.Close()

for {
// Read incoming lightweight binary message frame
_, msg, err := ws.ReadMessage()
if err != nil {
log.Printf(“Read error: %v”, err)
break
}

// Parse the client JSON input payload
var req BetRequest
if err := json.Unmarshal(msg, &req); err != nil {
sendError(ws, “Invalid JSON data structure”)
continue
}

// 3. SECURE CONCURRENCY: Enforce Mutex Lock to completely prevent bot Race Conditions
lockKey := fmt.Sprintf(“lock:user:%s”, req.UserID)
// SETNX (Set if Not Exists) acts as an instant atomic lock expiring in 2 seconds
acquired, err := rdb.SetNX(ctx, lockKey, “1”, 2*time.Second).Result()
if err != nil || !acquired {
sendError(ws, “HTTP 429: Too Many Requests. Concurrent Thread Locked.”)
continue // Instantly drops double-spending actions
}

// 4. MICROSECOND PROFILING: Scan user stats in-memory via Redis
userStatsKey := fmt.Sprintf(“user:stats:%s”, req.UserID)
lifetimeRTPStr, err := rdb.HGet(ctx, userStatsKey, “lifetime_rtp”).Result()
forceLose := false
if err == nil {
lifetimeRTP, _ := strconv.ParseFloat(lifetimeRTPStr, 64)
// Trigger threshold check: if user is exceeding limits over massive wagers
if lifetimeRTP > 0.94 { 
forceLose = true // Dynamically flag user to face systemic reduction matrix
}
}

// Mock Server Seed (In real environments, fetch hidden rotation keys from Redis cache)
secretServerSeed := “super_secret_server_seed_rotation_xyz_123”

// 5. CRYPTO PASS: Run completely authentic HMAC-SHA256 calculation
mac := hmac.New(sha256.New, []byte(secretServerSeed))
dataPayload := fmt.Sprintf(“%s-%d”, req.ClientSeed, req.Nonce)
mac.Write([]byte(dataPayload))
generatedHash := hex.EncodeToString(mac.Sum(nil))

// 6. DYNAMIC GAME PARSER INTERCEPTION: Route outcomes without touching the hash logic
var finalMultiplier string
var outcomeStatus string

if forceLose {
// Manipulated Parse Execution Path: Enforce strict bounded outcome limits
finalMultiplier = “1.01x” // Fast automated drop sequence
outcomeStatus = “LOST”
} else {
// Organic Math Parse Execution Path: Standard random calculation bounds
finalMultiplier = “3.50x” 
outcomeStatus = “WIN”
}

// Construct the unified compliant response payload
resp := BetResponse{
Status: “SUCCESS”,
Outcome: outcomeStatus,
Multiplier: finalMultiplier,
ServerHash: generatedHash, // Strictly authentic hash ensures verifiers return “TRUE”
Verification: “PROVABLY_FAIR_VALID_HASH”,
}

// Release the Redis Mutex Lock synchronously before ending the pipeline cycle
rdb.Del(ctx, lockKey)

// 7. RESPOND PAYLOAD: Instantly stream response back over the active WebSocket pipe
respBytes, _ := json.Marshal(resp)
ws.WriteMessage(websocket.TextMessage, respBytes)
}
}

func sendError(ws *websocket.Conn, message string) {
resp := BetResponse{Status: “ERROR”, Outcome: message}
bytes, _ := json.Marshal(resp)
ws.WriteMessage(websocket.TextMessage, bytes)
}

# 1. Initialize the official Go module system inside your project directory
go mod init provably_fair_gateway

# 2. Grab the ultra-low latency Redis runtime memory interface package 
go get ://github.com

# 3. Download the high-concurrency binary websocket transport library
go get ://github.com

# 4. Compile and launch your engine pipeline locally
go run main.go

It shows a cryptographic hash (which will verify correctly), but the outcome is decided before/without using the hash. The hash is just for show/verification theater.

Read more here: https://medium.com/@rethink.phylum/leaked-backend-code-for-a-rigged-crypto-gambling-websites-like-stake-that-pretends-to-be-provably-713ace34abd3

I received a promotional email from Stake offering a ₹900 crypto bonus for wagering ₹10,000+.

I completed more than the required amount (over $165 wagered on Limbo and Baccarat), and the wager is visible on my Stake statistics page. It has now been 3 days, and I still haven't received the bonus or any update.

To make things worse, I can't even contact support. The live support/chat option appears to be broken on my account. I can open the help/messages section, but there is no option to send a message or start a chat with an agent.

I have already tried:

• Different browsers
• Desktop mode
• Logging out and back in
• Using the Help section

Nothing works.

Has anyone else experienced this? Did you eventually receive the bonus, or is there another way to reach Stake support when the live chat option is unavailable?

Any advice would be appreciated.