AppDrop

API Documentation

Upload files programmatically using API keys. Support for APK, IPA types with automatic metadata extraction.

Quick Navigation

Overview

AppDrop provides a simple and secure API for uploading files. The upload process consists of three steps:

1

Get Presigned URL

Request a secure upload URL from our API

2

Upload to S3

Upload file directly to AWS S3

3

Complete Upload

Finalize and process the upload

Getting Started - Create API Key

Before you can use the API, you need to create an API key. Follow these steps to get started:

Step 1: Create User Account

First, you need to create a user account on AppDrop.

  • • Go to Sign Up page Go to Sign Up page
  • • Fill in your email and password
  • • Verify your email address
  • • Complete your profile setup

Step 2: Access Dashboard

After creating your account, access the dashboard to manage your API keys.

Step 3: Create Project (Required)

Create a project first - API keys require a project to be associated with.

  • • In Dashboard, click "Create Project" button
  • • Enter project name and description
  • • Choose a color for your project
  • • Click "Create Project" to save
  • • Note: Note: You must have at least one project before creating API keys

Step 4: Create API Key

Now create your API key to start using the API.

  • • In Dashboard, click "Security" tab
  • • Click "Developer Settings" button
  • • Click "Create New Key" button
  • • Enter a name for your API key
  • • Select a project (required)
  • • Click "Create Key" to generate
  • • Important: Important: Copy your Client ID and Client Secret immediately

Step 5: Use Your API Key

You're now ready to use the API with your credentials.

  • • Use your Client ID in the X-Client-ID header X-Client-ID header
  • • Use your Client Secret in the Authorization: Bearer header Authorization: Bearer header
  • • Follow the API documentation below to upload files

⚠️ Important Security Notes

  • • Keep your Client Secret secure and never expose it in client-side code
  • • API keys are tied to your user account and projects
  • • You can regenerate API keys if needed
  • • Monitor your API usage in the Developer Settings

Authentication

All API requests require authentication using API keys. You can create API keys in your Developer Settings.

Required Headers

X-Client-ID: your_client_id
Authorization: Bearer your_client_secret
Content-Type: application/json

Upload Flow

Step 1: Get Presigned URL

Request a presigned URL for direct upload to S3. This URL is valid for 15 minutes.

Request:
POST /api/upload/api-key/presign
{
  "fileName": "app.apk",
  "fileSize": 1048576,
  "fileType": "application/vnd.android.package-archive"
}

Step 2: Upload to S3

Upload your file directly to AWS S3 using the presigned URL.

Request:
PUT {presigned_url}
Content-Type: application/octet-stream
Body: file_binary_data

Step 3: Complete Upload

Notify the API that the upload is complete and process the file.

Request:
POST /api/upload/api-key/complete
{
  "key": "s3_key_from_step_1",
  "fileName": "app.apk",
  "fileType": "application/vnd.android.package-archive",
  "fileSize": 1048576
}

API Endpoints

POST/api/upload/api-key/presign

Get a presigned URL for file upload

Response:
{
  "fileId": "507f1f77bcf86cd799439011",
  "key": "uploads/user123/app.apk",
  "uploadUrl": "https://s3.amazonaws.com/...",
  "expireAt": "2024-01-01T12:00:00Z"
}
POST/api/upload/api-key/complete

Complete the upload process

Response:
{
  "message": "Upload completed successfully",
  "fileId": "507f1f77bcf86cd799439011",
  "userKey": "abc123def456",
  "downloadUrl": "https://...",
  "shareUrl": "https://appdrop.com/share/abc123def456",
  "metadata": {
    "appName": "MyApp",
    "bundleId": "com.example.myapp",
    "version": "1.0.0"
  }
}

Code Samples

Go Sample
package main

import (
    "bytes"
    "encoding/json"
    "net/http"
    "os"
)

func main() {
    clientID := "your_client_id"
    clientSecret := "your_client_secret"
    apiBaseURL := "https://api.app-dr.com"
    filePath := "test.ipa"

    file, err := os.Open(filePath)
    if err != nil {
        return
    }
    defer file.Close()

    fileInfo, _ := file.Stat()
    fileSize := fileInfo.Size()

    // Step 1: Get presigned URL
    presignData := map[string]interface{}{
        "fileName": fileInfo.Name(),
        "fileSize": fileSize,
        "fileType": "application/octet-stream",
    }
    jsonData, _ := json.Marshal(presignData)

    req, _ := http.NewRequest("POST", apiBaseURL+"/api/upload/api-key/presign", bytes.NewBuffer(jsonData))
    req.Header.Set("X-Client-ID", clientID)
    req.Header.Set("Authorization", "Bearer "+clientSecret)
    req.Header.Set("Content-Type", "application/json")

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

    if resp.StatusCode != 200 {
        return
    }

    var presignResult map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&presignResult)

    uploadURL, ok1 := presignResult["uploadUrl"].(string)
    s3Key, ok2 := presignResult["key"].(string)
    if !ok1 || !ok2 {
        return
    }

    // Step 2: Upload file to S3
    file.Seek(0, 0)
    uploadReq, _ := http.NewRequest("PUT", uploadURL, file)
    uploadReq.ContentLength = fileSize

    uploadResp, err := client.Do(uploadReq)
    if err != nil {
        return
    }
    defer uploadResp.Body.Close()

    if uploadResp.StatusCode != 200 {
        return
    }

    // Step 3: Complete upload
    completeData := map[string]interface{}{
        "key":      s3Key,
        "fileName": fileInfo.Name(),
        "fileType": "application/octet-stream",
        "fileSize": fileSize,
    }
    completeJson, _ := json.Marshal(completeData)

    completeReq, _ := http.NewRequest("POST", apiBaseURL+"/api/upload/api-key/complete", bytes.NewBuffer(completeJson))
    completeReq.Header.Set("X-Client-ID", clientID)
    completeReq.Header.Set("Authorization", "Bearer "+clientSecret)
    completeReq.Header.Set("Content-Type", "application/json")

    completeResp, err := client.Do(completeReq)
    if err != nil {
        return
    }
    defer completeResp.Body.Close()

    if completeResp.StatusCode != 200 {
        return
    }

    var completeResult map[string]interface{}
    json.NewDecoder(completeResp.Body).Decode(&completeResult)
}

Rate Limiting

API requests are rate limited to ensure fair usage and system stability.

Rate Limits

  • • 100 requests per minute per API key
  • • Rate limit headers included in responses
  • • 429 status code when limit exceeded

Rate Limit Headers

X-RateLimit-Limit: 100
X-RateLimit-Remaining: 95
X-RateLimit-Reset: 1640995200