Terabox Streaming & Paytm Gateway API

import hmac, hashlib, time, json, requests

API_KEY    = "tbx_your_api_key"
API_SECRET = "your_api_secret"
BASE_URL   = "https://api.mswpresents.tech"

def create_signature(api_secret, timestamp, body):
    """Create HMAC-SHA256 signature. No spaces after separators!"""
    body_str  = json.dumps(body, separators=(",", ":"), sort_keys=True)
    message   = f"{timestamp}:{body_str}"
    return hmac.new(api_secret.encode(), message.encode(), hashlib.sha256).hexdigest()

def get_link(terabox_url):
    timestamp = int(time.time())
    body      = {"url": terabox_url}
    signature = create_signature(API_SECRET, timestamp, body)
    headers   = {
        "X-API-Key":    API_KEY,
        "X-Signature":  signature,
        "X-Timestamp":  str(timestamp),
        "Content-Type": "application/json",
    }
    # Send raw JSON string to match the signature (data=, not json=)
    body_str = json.dumps(body, separators=(",", ":"), sort_keys=True)
    r = requests.post(f"{BASE_URL}/api/v1/terabox/get-link", data=body_str, headers=headers)
    return r.json()

result = get_link("https://terabox.com/s/1example")
print(result)

const crypto = require("crypto");
const axios  = require("axios");

const API_KEY    = "tbx_your_api_key";
const API_SECRET = "your_api_secret";
const BASE_URL   = "https://api.mswpresents.tech";

function createSignature(apiSecret, timestamp, body) {
  const bodyStr = JSON.stringify(body);
  const message = `${timestamp}:${bodyStr}`;
  return crypto.createHmac("sha256", apiSecret).update(message).digest("hex");
}

async function getLink(teraboxUrl) {
  const timestamp = Math.floor(Date.now() / 1000);
  const body      = { url: teraboxUrl };
  const signature = createSignature(API_SECRET, timestamp, body);
  const headers   = {
    "X-API-Key": API_KEY, "X-Signature": signature,
    "X-Timestamp": timestamp.toString(), "Content-Type": "application/json",
  };
  const res = await axios.post(`${BASE_URL}/api/v1/terabox/get-link`, body, { headers });
  return res.data;
}

getLink("https://terabox.com/s/1example").then(console.log);

<?php
define("API_KEY", "tbx_your_api_key");
define("API_SECRET", "your_api_secret");
define("BASE_URL", "https://api.mswpresents.tech");

function createSignature($apiSecret, $timestamp, $body) {
    $bodyStr = json_encode($body, JSON_UNESCAPED_SLASHES);
    return hash_hmac("sha256", "$timestamp:$bodyStr", $apiSecret);
}

function getLink($teraboxUrl) {
    $timestamp = time();
    $body      = ["url" => $teraboxUrl];
    $signature = createSignature(API_SECRET, $timestamp, $body);
    $headers   = [
        "X-API-Key: " . API_KEY,
        "X-Signature: " . $signature,
        "X-Timestamp: " . $timestamp,
        "Content-Type: application/json",
    ];
    $ch = curl_init(BASE_URL . "/api/v1/terabox/get-link");
    curl_setopt($ch, CURLOPT_POST, true);
    curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($body));
    curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    $response = curl_exec($ch);
    curl_close($ch);
    return json_decode($response, true);
}

print_r(getLink("https://terabox.com/s/1example"));

#!/bin/bash
API_KEY="tbx_your_api_key"
API_SECRET="your_api_secret"
BASE_URL="https://api.mswpresents.tech"
TIMESTAMP=$(date +%s)
TERABOX_URL="https://terabox.com/s/1example"

BODY='{"url":"'$TERABOX_URL'"}'
MESSAGE="${TIMESTAMP}:${BODY}"
SIGNATURE=$(echo -n "$MESSAGE" | openssl dgst -sha256 -hmac "$API_SECRET" | cut -d' ' -f2)

curl -X POST "${BASE_URL}/api/v1/terabox/get-link" \
  -H "X-API-Key: ${API_KEY}" \
  -H "X-Signature: ${SIGNATURE}" \
  -H "X-Timestamp: ${TIMESTAMP}" \
  -H "Content-Type: application/json" \
  -d "$BODY"

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.net.http.*;
import java.net.URI;
import com.google.gson.Gson;

public class TeraboxAPI {
    private static final String API_KEY    = "tbx_your_api_key";
    private static final String API_SECRET = "your_api_secret";
    private static final String BASE_URL   = "https://api.mswpresents.tech";

    public static String createSignature(String apiSecret, long timestamp, String body) throws Exception {
        String message = timestamp + ":" + body;
        Mac hmac = Mac.getInstance("HmacSHA256");
        hmac.init(new SecretKeySpec(apiSecret.getBytes(), "HmacSHA256"));
        byte[] hash = hmac.doFinal(message.getBytes());
        StringBuilder hex = new StringBuilder();
        for (byte b : hash) {
            String h = Integer.toHexString(0xff & b);
            if (h.length() == 1) hex.append('0');
            hex.append(h);
        }
        return hex.toString();
    }

    public static String getLink(String teraboxUrl) throws Exception {
        long timestamp = System.currentTimeMillis() / 1000;
        String body   = new Gson().toJson(Map.of("url", teraboxUrl));
        String sig    = createSignature(API_SECRET, timestamp, body);

        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(BASE_URL + "/api/v1/terabox/get-link"))
            .header("X-API-Key", API_KEY)
            .header("X-Signature", sig)
            .header("X-Timestamp", String.valueOf(timestamp))
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(body))
            .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        return response.body();
    }
}

package main

import (
    "bytes"
    "crypto/hmac"
    "crypto/sha256"
    "encoding/hex"
    "encoding/json"
    "fmt"
    "net/http"
    "strconv"
    "time"
)

const (
    APIKey    = "tbx_your_api_key"
    APISecret = "your_api_secret"
    BaseURL   = "https://api.mswpresents.tech"
)

func createSignature(apiSecret string, timestamp int64, body []byte) string {
    message := fmt.Sprintf("%d:%s", timestamp, string(body))
    h := hmac.New(sha256.New, []byte(apiSecret))
    h.Write([]byte(message))
    return hex.EncodeToString(h.Sum(nil))
}

func getLink(teraboxURL string) (string, error) {
    timestamp := time.Now().Unix()
    bodyMap := map[string]string{"url": teraboxURL}
    body, _ := json.Marshal(bodyMap)
    signature := createSignature(APISecret, timestamp, body)

    req, _ := http.NewRequest("POST", BaseURL+"/api/v1/terabox/get-link",
                              bytes.NewBuffer(body))
    req.Header.Set("X-API-Key", APIKey)
    req.Header.Set("X-Signature", signature)
    req.Header.Set("X-Timestamp", strconv.FormatInt(timestamp, 10))
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil { return "", err }
    defer resp.Body.Close()

    var result map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&result)
    resultJSON, _ := json.MarshalIndent(result, "", "  ")
    return string(resultJSON), nil
}

func main() {
    result, _ := getLink("https://terabox.com/s/1example")
    fmt.Println(result)
}

require 'openssl'
require 'json'
require 'net/http'
require 'uri'

API_KEY    = 'tbx_your_api_key'
API_SECRET = 'your_api_secret'
BASE_URL   = 'https://api.mswpresents.tech'

def create_signature(api_secret, timestamp, body)
  body_str = body.to_json
  message  = "#{timestamp}:#{body_str}"
  OpenSSL::HMAC.hexdigest('SHA256', api_secret, message)
end

def get_link(terabox_url)
  timestamp = Time.now.to_i
  body      = { url: terabox_url }
  signature = create_signature(API_SECRET, timestamp, body)

  uri  = URI("#{BASE_URL}/api/v1/terabox/get-link")
  http = Net::HTTP.new(uri.host, uri.port)
  http.use_ssl = true

  request = Net::HTTP::Post.new(uri.path)
  request['X-API-Key']    = API_KEY
  request['X-Signature']  = signature
  request['X-Timestamp']  = timestamp.to_s
  request['Content-Type'] = 'application/json'
  request.body = body.to_json

  response = http.request(request)
  JSON.parse(response.body)
end

result = get_link('https://terabox.com/s/1example')
puts JSON.pretty_generate(result)

using System;
using System.Net.Http;
using System.Security.Cryptography;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

public class TeraboxAPI
{
    private const string API_KEY    = "tbx_your_api_key";
    private const string API_SECRET = "your_api_secret";
    private const string BASE_URL   = "https://api.mswpresents.tech";

    public static string CreateSignature(string apiSecret, long timestamp, string body)
    {
        string message = $"{timestamp}:{body}";
        using (var hmac = new HMACSHA256(Encoding.UTF8.GetBytes(apiSecret)))
        {
            byte[] hash = hmac.ComputeHash(Encoding.UTF8.GetBytes(message));
            return BitConverter.ToString(hash).Replace("-", "").ToLower();
        }
    }

    public static async Task<string> GetLink(string teraboxUrl)
    {
        long timestamp = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
        var bodyObj    = new { url = teraboxUrl };
        string body    = JsonSerializer.Serialize(bodyObj);
        string sig     = CreateSignature(API_SECRET, timestamp, body);

        using (var client = new HttpClient())
        {
            var request = new HttpRequestMessage(HttpMethod.Post,
                $"{BASE_URL}/api/v1/terabox/get-link");
            request.Headers.Add("X-API-Key", API_KEY);
            request.Headers.Add("X-Signature", sig);
            request.Headers.Add("X-Timestamp", timestamp.ToString());
            request.Content = new StringContent(body, Encoding.UTF8, "application/json");

            var response = await client.SendAsync(request);
            return await response.Content.ReadAsStringAsync();
        }
    }
}