> ## Documentation Index
> Fetch the complete documentation index at: https://docs.dropkit.co/llms.txt
> Use this file to discover all available pages before exploring further.

# Quick Start Guide

> Launch your first drop with DropKit GraphQL API in under 5 minutes

## Create Your First Drop

Learn how to use DropKit's GraphQL API to launch drops, process payments, and manage the entire customer experience.

### Authentication Setup

<AccordionGroup>
  <Accordion icon="key" title="Get your API key">
    To start using DropKit's GraphQL API, you'll need an API key:

    1. Sign up at [app.dropkit.co](https://app.dropkit.co)
    2. Navigate to your dashboard
    3. Go to Settings > API Keys
    4. Generate a new API key and keep it secure
  </Accordion>

  <Accordion icon="shield" title="Authentication">
    All GraphQL requests require authentication using Bearer tokens in the header:

    ```bash theme={null}
    curl -X POST https://api.dropkit.co/graphql \
      -H "Authorization: Bearer YOUR_API_KEY" \
      -H "Content-Type: application/json" \
      -d '{"query": "query { me { id username } }"}'
    ```
  </Accordion>
</AccordionGroup>

### Create Your First Token

Before creating drops, you'll need to create a token:

<AccordionGroup>
  <Accordion icon="coins" title="Create a Token">
    Create a fungible token that will be used in your drops:

    ```bash theme={null}
    curl -X POST https://api.dropkit.co/graphql \
      -H "Authorization: Bearer YOUR_API_KEY" \
      -H "Content-Type: application/json" \
      -d '{
        "query": "mutation CreateToken($input: CreateTokenInput!) { createToken(input: $input) { id name symbol status address } }",
        "variables": {
          "input": {
            "name": "My Creator Token",
            "symbol": "MCT",
            "supply": 1000000,
            "description": "A token for my community"
          }
        }
      }'
    ```

    **Response:**

    ```json theme={null}
    {
      "data": {
        "createToken": {
          "id": "token_abc123",
          "name": "My Creator Token",
          "symbol": "MCT",
          "status": "PENDING",
          "address": null
        }
      }
    }
    ```
  </Accordion>
</AccordionGroup>

### Launch Your First Drop

<AccordionGroup>
  <Accordion icon="image" title="Create a Token Drop">
    Create a token drop using your newly created token:

    ```bash theme={null}
    curl -X POST https://api.dropkit.co/graphql \
      -H "Authorization: Bearer YOUR_API_KEY" \
      -H "Content-Type: application/json" \
      -d '{
        "query": "mutation CreateDrop($input: CreateDropInput!) { createDrop(input: $input) { id title shortcode status type claimType maxAmount tokenAmount token { name symbol } } }",
        "variables": {
          "input": {
            "title": "Community Token Drop",
            "description": "A drop for early supporters",
            "type": "TOKEN",
            "claimType": "REGULAR",
            "maxAmount": "100000",
            "tokenAmount": "100",
            "existingTokenId": "token_abc123",
            "estimatedValueUsd": 10.0
          }
        }
      }'
    ```

    **Response:**

    ```json theme={null}
    {
      "data": {
        "createDrop": {
          "id": "drop_xyz789",
          "title": "Community Token Drop",
          "shortcode": "community-token-drop",
          "status": "ACTIVE",
          "type": "TOKEN",
          "claimType": "REGULAR",
          "maxAmount": "100000",
          "tokenAmount": "100",
          "token": {
            "name": "My Creator Token",
            "symbol": "MCT"
          }
        }
      }
    }
    ```
  </Accordion>

  <Accordion icon="gift" title="Create an NFT Drop">
    Create an NFT drop:

    ```bash theme={null}
    curl -X POST https://api.dropkit.co/graphql \
      -H "Authorization: Bearer YOUR_API_KEY" \
      -H "Content-Type: application/json" \
      -d '{
        "query": "mutation CreateDrop($input: CreateDropInput!) { createDrop(input: $input) { id title shortcode type price supply } }",
        "variables": {
          "input": {
            "title": "Genesis NFT Collection",
            "description": "Limited edition NFT collection",
            "type": "NFT",
            "claimType": "REGULAR",
            "maxAmount": "1000",
            "tokenAmount": "1",
            "existingTokenId": "token_nft123",
            "price": 5.0,
            "supply": 1000,
            "imageUrl": "https://example.com/nft-collection.png"
          }
        }
      }'
    ```
  </Accordion>
</AccordionGroup>

### View Your Drops

<AccordionGroup>
  <Accordion icon="list" title="List Your Drops">
    Get all your drops:

    ```bash theme={null}
    curl -X POST https://api.dropkit.co/graphql \
      -H "Authorization: Bearer YOUR_API_KEY" \
      -H "Content-Type: application/json" \
      -d '{
        "query": "query GetMyDrops { myDrops { id title status type claimedAmount maxAmount claimRate claimCount createdAt token { name symbol } } }"
      }'
    ```

    **Response:**

    ```json theme={null}
    {
      "data": {
        "myDrops": [
          {
            "id": "drop_xyz789",
            "title": "Community Token Drop",
            "status": "ACTIVE",
            "type": "TOKEN",
            "claimedAmount": "2500",
            "maxAmount": "100000",
            "claimRate": 2.5,
            "claimCount": 25,
            "createdAt": "2024-01-15T10:30:00Z",
            "token": {
              "name": "My Creator Token",
              "symbol": "MCT"
            }
          }
        ]
      }
    }
    ```
  </Accordion>

  <Accordion icon="chart-line" title="Get Drop Statistics">
    Get detailed statistics for a specific drop:

    ```bash theme={null}
    curl -X POST https://api.dropkit.co/graphql \
      -H "Authorization: Bearer YOUR_API_KEY" \
      -H "Content-Type: application/json" \
      -d '{
        "query": "query GetDropStats($id: ID!) { dropDashboardStats(id: $id) { totalClaims recentClaims claimRate totalAmount claimedAmount recentActivity { id type description timestamp } } }",
        "variables": {
          "id": "drop_xyz789"
        }
      }'
    ```
  </Accordion>
</AccordionGroup>

## Process Payments

Handle purchases with multiple payment methods including crypto.

<AccordionGroup>
  <Accordion icon="credit-card" title="Create Payment Intent">
    Process a purchase with payment intents:

    ```bash theme={null}
    curl -X POST https://api.dropkit.co/graphql \
      -H "Authorization: Bearer YOUR_API_KEY" \
      -H "Content-Type: application/json" \
      -d '{
        "query": "mutation CreatePaymentIntent($input: CreatePaymentIntentInput!) { createPaymentIntent(input: $input) { id intentId status amount paymentUrl expiresAt } }",
        "variables": {
          "input": {
            "dropId": "drop_xyz789",
            "walletAddress": "0x123...",
            "paymentMethod": "sui",
            "quantity": 2
          }
        }
      }'
    ```

    **Response:**

    ```json theme={null}
    {
      "data": {
        "createPaymentIntent": {
          "id": "pi_abc123",
          "intentId": "pi_xyz789",
          "status": "PENDING",
          "amount": 10.0,
          "paymentUrl": "https://pay.moral.capital/intents/pi_xyz789",
          "expiresAt": "2024-01-15T11:30:00Z"
        }
      }
    }
    ```
  </Accordion>

  <Accordion icon="check" title="Confirm Payment">
    Confirm a payment after completion:

    ```bash theme={null}
    curl -X POST https://api.dropkit.co/graphql \
      -H "Authorization: Bearer YOUR_API_KEY" \
      -H "Content-Type: application/json" \
      -d '{
        "query": "mutation ConfirmPayment($id: ID!, $txHash: String) { confirmPaymentIntent(id: $id, txHash: $txHash) { id status amount } }",
        "variables": {
          "id": "pi_abc123",
          "txHash": "0x123abc..."
        }
      }'
    ```
  </Accordion>
</AccordionGroup>

## Claiming Drops

Enable users to claim tokens or NFTs from your drops.

<AccordionGroup>
  <Accordion icon="hand-holding-dollar" title="Claim Tokens">
    Process a token claim:

    ```bash theme={null}
    curl -X POST https://api.dropkit.co/graphql \
      -H "Authorization: Bearer YOUR_API_KEY" \
      -H "Content-Type: application/json" \
      -d '{
        "query": "mutation ClaimTokens($input: ClaimDropInput!) { claimDrop(input: $input) { claim { id amount claimedAt user { username } } claimParams { amount nonce expiry signature } dropInfo { dropObjectId packageId coinType } } }",
        "variables": {
          "input": {
            "dropId": "drop_xyz789",
            "amount": "100",
            "userAddress": "0x123..."
          }
        }
      }'
    ```
  </Accordion>

  <Accordion icon="dice" title="Claim Random Amount">
    For drops with random amounts:

    ```bash theme={null}
    curl -X POST https://api.dropkit.co/graphql \
      -H "Authorization: Bearer YOUR_API_KEY" \
      -H "Content-Type: application/json" \
      -d '{
        "query": "mutation ClaimRandom($input: ClaimRandomDropInput!) { claimRandomDrop(input: $input) { success message claimedAmount claim { id amount } } }",
        "variables": {
          "input": {
            "dropId": "drop_xyz789",
            "userAddress": "0x123..."
          }
        }
      }'
    ```
  </Accordion>
</AccordionGroup>

## Access Control & Gating

Create eligibility requirements for your drops.

<AccordionGroup>
  <Accordion icon="shield-check" title="Check Eligibility">
    Verify if a wallet meets requirements:

    ```bash theme={null}
    curl -X POST https://api.dropkit.co/graphql \
      -H "Authorization: Bearer YOUR_API_KEY" \
      -H "Content-Type: application/json" \
      -d '{
        "query": "query CheckEligibility($input: GatingCheckInput!) { checkGatingEligibility(input: $input) { eligible reason missingRequirements } }",
        "variables": {
          "input": {
            "dropId": "drop_xyz789",
            "walletAddress": "0x123..."
          }
        }
      }'
    ```

    **Response:**

    ```json theme={null}
    {
      "data": {
        "checkGatingEligibility": {
          "eligible": true,
          "reason": "All requirements met",
          "missingRequirements": []
        }
      }
    }
    ```
  </Accordion>

  <Accordion icon="cog" title="Configure Gating Rules">
    Set up gating rules for a drop:

    ```bash theme={null}
    curl -X POST https://api.dropkit.co/graphql \
      -H "Authorization: Bearer YOUR_API_KEY" \
      -H "Content-Type: application/json" \
      -d '{
        "query": "mutation UpdateGating($dropId: ID!, $input: UpdateGatingConfigInput!) { updateGatingConfig(dropId: $dropId, input: $input) { id isActive rules { key operator value description } } }",
        "variables": {
          "dropId": "drop_xyz789",
          "input": {
            "isActive": true,
            "rules": [
              {
                "key": "token_balance",
                "operator": ">=",
                "value": "100",
                "description": "Must hold at least 100 tokens"
              }
            ]
          }
        }
      }'
    ```
  </Accordion>

  <Accordion icon="template" title="Use Gating Templates">
    Get available gating templates:

    ```bash theme={null}
    curl -X POST https://api.dropkit.co/graphql \
      -H "Authorization: Bearer YOUR_API_KEY" \
      -H "Content-Type: application/json" \
      -d '{
        "query": "query GetGatingTemplates { gatingTemplates { id name description category rules { key operator value description } } }"
      }'
    ```
  </Accordion>
</AccordionGroup>

## Track Activity

Monitor events and analytics across your drops.

<AccordionGroup>
  <Accordion icon="chart-bar" title="Platform Events">
    Get platform events for monitoring:

    ```bash theme={null}
    curl -X POST https://api.dropkit.co/graphql \
      -H "Authorization: Bearer YOUR_API_KEY" \
      -H "Content-Type: application/json" \
      -d '{
        "query": "query GetPlatformEvents($dropId: ID, $limit: Int) { platformEvents(dropId: $dropId, limit: $limit) { id event timestamp details drop { title } user { username } } }",
        "variables": {
          "dropId": "drop_xyz789",
          "limit": 10
        }
      }'
    ```
  </Accordion>

  <Accordion icon="bell" title="Setup Webhooks">
    Register webhooks for real-time notifications:

    ```bash theme={null}
    curl -X POST https://api.dropkit.co/graphql \
      -H "Authorization: Bearer YOUR_API_KEY" \
      -H "Content-Type: application/json" \
      -d '{
        "query": "mutation RegisterWebhook($input: RegisterWebhookInput!) { registerWebhook(input: $input) { id webhookId url events secret isActive } }",
        "variables": {
          "input": {
            "url": "https://your-app.com/webhooks/dropkit",
            "events": ["drop.claimed", "payment.confirmed", "drop.completed"]
          }
        }
      }'
    ```
  </Accordion>
</AccordionGroup>

## Advanced Features

### User Management

<AccordionGroup>
  <Accordion icon="user" title="Get User Profile">
    Get your user profile:

    ```bash theme={null}
    curl -X POST https://api.dropkit.co/graphql \
      -H "Authorization: Bearer YOUR_API_KEY" \
      -H "Content-Type: application/json" \
      -d '{
        "query": "query GetMyProfile { me { id username displayName bio avatar email createdAt } }"
      }'
    ```
  </Accordion>

  <Accordion icon="edit" title="Update Profile">
    Update your profile information:

    ```bash theme={null}
    curl -X POST https://api.dropkit.co/graphql \
      -H "Authorization: Bearer YOUR_API_KEY" \
      -H "Content-Type: application/json" \
      -d '{
        "query": "mutation UpdateProfile($input: UpdateProfileInput!) { updateProfile(input: $input) { id username displayName bio avatar } }",
        "variables": {
          "input": {
            "displayName": "Creator Name",
            "bio": "Building the future of digital collectibles",
            "avatar": "https://example.com/avatar.png"
          }
        }
      }'
    ```
  </Accordion>
</AccordionGroup>

### File Management

<AccordionGroup>
  <Accordion icon="upload" title="Upload Files">
    Upload images and other files:

    ```bash theme={null}
    curl -X POST https://api.dropkit.co/graphql \
      -H "Authorization: Bearer YOUR_API_KEY" \
      -H "Content-Type: application/json" \
      -d '{
        "query": "mutation UploadFile($input: UploadFileInput!) { uploadFile(input: $input) { url filename size contentType } }",
        "variables": {
          "input": {
            "file": "base64_encoded_file_content",
            "filename": "drop-image.png",
            "contentType": "image/png"
          }
        }
      }'
    ```
  </Accordion>
</AccordionGroup>

## Next Steps

Now that you've created your first drop, explore:

* **[Schema Explorer](/api-reference/schema-explorer)** - Browse the complete GraphQL schema
* **[Drop Queries](/api-reference/queries/drops)** - Learn advanced query patterns
* **[Mutations](/api-reference/mutations)** - Master all available operations
* **[Types Documentation](/api-reference/types)** - Understand the data model

## GraphQL Benefits

### Powerful Queries

* Fetch exactly the data you need
* Get related data in a single request
* Real-time computed fields

### Type Safety

* Strongly typed schema
* Built-in validation
* Auto-completion support

### Flexibility

* Multiple operations in one request
* Aliases for complex queries
* Fragments for reusable selections

### Performance

* Efficient data fetching
* Reduced over-fetching
* Optimized for mobile apps