API Reference — GitDeploy

📡 API Reference

Base URL: https://gitdeploy.my.id

v1 REST

Deployment

POST /api/deploy multipart/form-data

Deploy project files to a GitHub repository. Creates the repo if it doesn't exist. Supports nested folders via webkitRelativePath. Token is never stored — discarded after request.

Parameters

Field	Type	Required	Description
X-GitHub-Token (header)	string	required	GitHub personal access token. Needs `repo` scope. Never stored.
repoName	string	required	Repository name. Created automatically if it doesn't exist.
files[]	file[]	required	One or more files. Supports subfolders via filename (e.g. `src/index.js`).
branch	string	optional	Target branch. Default: `main`. Created if not exists.
commitMessage	string	optional	Git commit message. Default: `Deploy via GitDeploy`.
description	string	optional	Repository description (used on creation).
private	boolean	optional	Create as private repository. Default: `false`.

Code Examples

# Deploy with cURL (supports subfolder paths via filename)
curl -X POST https://gitdeploy.my.id/api/deploy \
  -H "X-GitHub-Token: ghp_yourPersonalAccessToken" \
  -F "repoName=my-project" \
  -F "branch=main" \
  -F "commitMessage=feat: initial deploy" \
  -F "description=My awesome project" \
  -F "private=false" \
  -F "files=@./index.html;filename=index.html" \
  -F "files=@./src/app.js;filename=src/app.js" \
  -F "files=@./src/css/style.css;filename=src/css/style.css"

# Success response:
{
  "success": true,
  "repoName": "my-project",
  "branch": "main",
  "commitSha": "abc123...",
  "filesDeployed": 3,
  "repoUrl": "https://github.com/user/my-project",
  "commitUrl": "https://github.com/user/my-project/commit/abc123"
}

// ESM — Native Fetch (Node 18+ or browser)
const deployProject = async (token, files) => {
  const form = new FormData();
  form.append('repoName',      'my-project');
  form.append('branch',        'main');
  form.append('commitMessage', 'feat: deploy via API');
  form.append('description',   'Deployed with GitDeploy');

  files.forEach(({ buffer, relativePath }) => {
    form.append('files', new Blob([buffer]), relativePath);
  });

  const res = await fetch('https://gitdeploy.my.id/api/deploy', {
    method:  'POST',
    headers: { 'X-GitHub-Token': token },
    body:    form
  });

  if (!res.ok) throw new Error(`Deploy failed: ${res.status}`);
  return res.json();
};

export { deployProject };

// CJS — Native Fetch (Node 18+)
const deployProject = async (token, files) => {
  const form = new FormData();
  form.append('repoName',      'my-project');
  form.append('branch',        'main');
  form.append('commitMessage', 'feat: deploy via API');

  files.forEach(({ buffer, relativePath }) => {
    form.append('files', new Blob([buffer]), relativePath);
  });

  const res = await fetch('https://gitdeploy.my.id/api/deploy', {
    method:  'POST',
    headers: { 'X-GitHub-Token': token },
    body:    form
  });

  if (!res.ok) throw new Error(`Deploy failed: ${res.status}`);
  return res.json();
};

module.exports = { deployProject };

// ESM — Axios
import axios    from 'axios';
import FormData from 'form-data';
import { readFileSync } from 'fs';

const deployProject = async (token, fileList) => {
  const form = new FormData();
  form.append('repoName',      'my-project');
  form.append('branch',        'main');
  form.append('commitMessage', 'deploy: via Axios ESM');
  form.append('description',   'Deployed via GitDeploy API');

  fileList.forEach(({ path, relativePath }) => {
    form.append('files', readFileSync(path), { filename: relativePath });
  });

  const { data } = await axios.post(
    'https://gitdeploy.my.id/api/deploy',
    form,
    { headers: { ...form.getHeaders(), 'X-GitHub-Token': token } }
  );
  return data;
};

export { deployProject };

// CJS — Axios
const axios    = require('axios');
const FormData = require('form-data');
const { readFileSync } = require('fs');

const deployProject = async (token, fileList) => {
  const form = new FormData();
  form.append('repoName',      'my-project');
  form.append('branch',        'main');
  form.append('commitMessage', 'deploy: via Axios CJS');

  fileList.forEach(({ path, relativePath }) => {
    form.append('files', readFileSync(path), { filename: relativePath });
  });

  const { data } = await axios.post(
    'https://gitdeploy.my.id/api/deploy',
    form,
    { headers: { ...form.getHeaders(), 'X-GitHub-Token': token } }
  );
  return data;
};

module.exports = { deployProject };

# Python — requests
import requests

def deploy_project(token: str, file_list: list[dict]) -> dict:
    """
    file_list: [{"path": "/local/path", "relative_path": "src/index.py"}]
    """
    files = []
    for f in file_list:
        files.append((
            "files",
            (f["relative_path"], open(f["path"], "rb"), "application/octet-stream")
        ))

    response = requests.post(
        "https://gitdeploy.my.id/api/deploy",
        headers={"X-GitHub-Token": token},
        data={
            "repoName":      "my-project",
            "branch":        "main",
            "commitMessage": "deploy: from Python",
            "description":   "Deployed via GitDeploy API",
            "private":       "false"
        },
        files=files
    )
    response.raise_for_status()
    return response.json()

# Usage
result = deploy_project(
    token="ghp_yourtoken",
    file_list=[
        {"path": "./index.py",     "relative_path": "index.py"},
        {"path": "./src/utils.py", "relative_path": "src/utils.py"}
    ]
)
print(result["repoUrl"])

// PHP — cURL multipart
function deployProject($token, $files): array {
    // $files = [["path" => "/local/path", "relative_path" => "src/index.php"]]
    $ch         = curl_init();
    $postFields = [
        'repoName'      => 'my-project',
        'branch'        => 'main',
        'commitMessage' => 'deploy: from PHP',
        'description'   => 'Deployed via GitDeploy API',
        'private'       => 'false',
    ];

    foreach ($files as $i => $file) {
        $postFields["files[{$i}]"] = new CURLFile(
            $file['path'], 'application/octet-stream', $file['relative_path']
        );
    }

    curl_setopt_array($ch, [
        CURLOPT_URL            => 'https://gitdeploy.my.id/api/deploy',
        CURLOPT_POST           => true,
        CURLOPT_POSTFIELDS     => $postFields,
        CURLOPT_HTTPHEADER     => ["X-GitHub-Token: {$token}"],
        CURLOPT_RETURNTRANSFER => true,
    ]);

    $response = curl_exec($ch);
    $status   = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);

    if ($status !== 200) {
        throw new RuntimeException("Deploy failed: {$response}");
    }
    return json_decode($response, true);
}

// Usage
$result = deployProject('ghp_yourtoken', [
    ['path' => './index.php',     'relative_path' => 'index.php'],
    ['path' => './src/utils.php', 'relative_path' => 'src/utils.php'],
]);
echo $result['repoUrl'];

# Ruby — net/http multipart
require 'net/http'
require 'uri'
require 'json'

def deploy_project(token, files)
  uri      = URI('https://gitdeploy.my.id/api/deploy')
  boundary = "GitDeployBoundary#{Time.now.to_i}"
  parts    = []

  {
    'repoName'      => 'my-project',
    'branch'        => 'main',
    'commitMessage' => 'deploy: from Ruby',
    'description'   => 'Deployed via GitDeploy'
  }.each do |k, v|
    parts << "--#{boundary}\r\nContent-Disposition: form-data; name=\"#{k}\"\r\n\r\n#{v}"
  end

  files.each do |f|
    content = File.binread(f[:path])
    parts << "--#{boundary}\r\nContent-Disposition: form-data; name=\"files\"; filename=\"#{f[:relative_path]}\"\r\nContent-Type: application/octet-stream\r\n\r\n#{content}"
  end

  http         = Net::HTTP.new(uri.host, uri.port)
  http.use_ssl = true
  req          = Net::HTTP::Post.new(uri.path)
  req['Content-Type']    = "multipart/form-data; boundary=#{boundary}"
  req['X-GitHub-Token'] = token
  req.body = parts.join("\r\n") + "\r\n--#{boundary}--"

  JSON.parse(http.request(req).body)
end

⚡ Try it out

X-GitHub-Token * (needs repo scope)

repoName *

branch

commitMessage

description

private

files[] *

Repositories

DELETE /api/repos/:repoName PAT Required

Permanently delete a repository. Requires a GitHub personal access token with delete_repo scope via X-GitHub-Token header. Login not required — token is discarded immediately after.

curl -X DELETE https://gitdeploy.my.id/api/repos/my-project \
  -H "X-GitHub-Token: ghp_yourPersonalAccessToken"

# Response: { "success": true, "deleted": true, "repoName": "my-project" }

const deleteRepo = async (repoName, token) => {
  const res = await fetch(`https://gitdeploy.my.id/api/repos/${repoName}`, {
    method:  'DELETE',
    headers: { 'X-GitHub-Token': token }
  });
  if (!res.ok) throw new Error('Delete failed');
  return res.json();
};
export { deleteRepo };

const deleteRepo = async (repoName, token) => {
  const res = await fetch(`https://gitdeploy.my.id/api/repos/${repoName}`, {
    method:  'DELETE',
    headers: { 'X-GitHub-Token': token }
  });
  if (!res.ok) throw new Error('Delete failed');
  return res.json();
};
module.exports = { deleteRepo };

import axios from 'axios';

const deleteRepo = async (repoName, token) => {
  const { data } = await axios.delete(
    `https://gitdeploy.my.id/api/repos/${repoName}`,
    { headers: { 'X-GitHub-Token': token } }
  );
  return data;
};
export { deleteRepo };

const axios = require('axios');

const deleteRepo = async (repoName, token) => {
  const { data } = await axios.delete(
    `https://gitdeploy.my.id/api/repos/${repoName}`,
    { headers: { 'X-GitHub-Token': token } }
  );
  return data;
};
module.exports = { deleteRepo };

import requests

def delete_repo(repo_name: str, token: str) -> dict:
    res = requests.delete(
        f'https://gitdeploy.my.id/api/repos/{repo_name}',
        headers={'X-GitHub-Token': token}
    )
    res.raise_for_status()
    return res.json()

# Usage
result = delete_repo('my-project', 'ghp_yourtoken')
print(result)

$repoName = 'my-project';
$ch = curl_init("https://gitdeploy.my.id/api/repos/{$repoName}");
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST  => 'DELETE',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => ["X-GitHub-Token: ghp_yourtoken"],
]);
$res = json_decode(curl_exec($ch), true);
curl_close($ch);
print_r($res);

repo_name = 'my-project'
uri       = URI("https://gitdeploy.my.id/api/repos/#{repo_name}")
http      = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
req       = Net::HTTP::Delete.new(uri)
req['X-GitHub-Token'] = 'ghp_yourtoken'
result    = JSON.parse(http.request(req).body)
puts result

⚡ Try it out

⚠️ This permanently deletes the repository and cannot be undone.

X-GitHub-Token * (needs delete_repo scope)

repoName *