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

# Complete Order

> Mark order as delivered and complete

## Overview

Marks an order as successfully delivered to the customer. Changes order status to `COMPLETE_WITH_PAYMENT`.

<Info>
  **All orders** are marked as `COMPLETE_WITH_PAYMENT` regardless of payment type (including CASH). This indicates successful delivery and payment confirmation.
</Info>

## Path Parameters

<ParamField path="order_id" type="string" required>
  Order's `payment_key` (UUID)
</ParamField>

## Headers

<ParamField header="Access-Token" type="string" required>
  Your API access token
</ParamField>

## Response

<ResponseField name="status" type="boolean">
  `true` if successful
</ResponseField>

<ResponseField name="data" type="string">
  `"OK"` on success
</ResponseField>

## Examples

<CodeGroup>
  ```bash cURL theme={null}
  curl -X PUT https://www.xn--dkkango-n2a.com/api/integrations/orders/complete/3e9caf87-5cb7-4c4e-adcb-fc2ec54cf24e \
    -H 'Access-Token: your-access-token'
  ```

  ```javascript JavaScript theme={null}
  const paymentKey = '3e9caf87-5cb7-4c4e-adcb-fc2ec54cf24e';

  const response = await fetch(
    `https://www.xn--dkkango-n2a.com/api/integrations/orders/complete/${paymentKey}`,
    {
      method: 'PUT',
      headers: {
        'Access-Token': 'your-access-token'
      }
    }
  );

  const data = await response.json();
  // Order is now COMPLETE_WITH_PAYMENT
  ```

  ```python Python theme={null}
  import requests

  payment_key = '3e9caf87-5cb7-4c4e-adcb-fc2ec54cf24e'

  response = requests.put(
      f'https://www.xn--dkkango-n2a.com/api/integrations/orders/complete/{payment_key}',
      headers={'Access-Token': 'your-access-token'}
  )

  data = response.json()
  # Order is now COMPLETE_WITH_PAYMENT
  ```

  ```php PHP theme={null}
  <?php
  $paymentKey = '3e9caf87-5cb7-4c4e-adcb-fc2ec54cf24e';
  $url = "https://www.xn--dkkango-n2a.com/api/integrations/orders/complete/{$paymentKey}";

  $ch = curl_init();
  curl_setopt($ch, CURLOPT_URL, $url);
  curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "PUT");
  curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
  curl_setopt($ch, CURLOPT_HTTPHEADER, array(
      'Access-Token: your-access-token'
  ));
  $response = curl_exec($ch);
  curl_close($ch);
  // Order is now COMPLETE_WITH_PAYMENT
  ?>
  ```
</CodeGroup>

## Success Response (200)

```json theme={null}
{
  "status": true,
  "data": "OK"
}
```

## Error Responses

<ResponseExample>
  ```json Authentication Error (401) theme={null}
  {
    "status": false,
    "error": "yetkisiz erişim"
  }
  ```

  ```json Invalid UUID (403) theme={null}
  {
    "status": false,
    "error": "URL hatalı"
  }
  ```

  ```json Not Found (404) theme={null}
  {
    "status": false,
    "error": "sipariş bulunamadı"
  }
  ```
</ResponseExample>

## Status Transition

```
IN_DELIVERY (status_id: 16)
    ↓
[/orders/complete called]
    ↓
COMPLETE_WITH_PAYMENT (status_id: 5)
```

## Payment Handling

<Tabs>
  <Tab title="Cash Payment">
    ```javascript theme={null}
    async function completeCashOrder(order) {
      // 1. Courier confirms cash received
      const cashReceived = await confirmCashPayment(order.total);
      
      if (cashReceived) {
        // 2. Complete order
        await completeOrder(order.payment_key);
        
        // 3. Log cash collection
        await logCashCollection({
          orderId: order.id,
          amount: order.total,
          courierId: currentCourier.id,
          timestamp: new Date()
        });
        
        console.log(`✅ Cash order ${order.id} completed`);
      }
    }
    ```
  </Tab>

  <Tab title="Card Payment">
    ```javascript theme={null}
    async function completeCardOrder(order) {
      // Card already processed - just confirm delivery
      await completeOrder(order.payment_key);
      
      console.log(`✅ Card order ${order.id} completed`);
    }
    ```
  </Tab>

  <Tab title="Any Payment Type">
    ```javascript theme={null}
    async function completeOrder(order) {
      // All payment types use same endpoint
      await apiClient.put(`/orders/complete/${order.payment_key}`);
      
      // Status: COMPLETE_WITH_PAYMENT (regardless of payment type)
      await updateLocalStatus(order.id, 'complete');
    }
    ```
  </Tab>
</Tabs>

<Note>
  **All payment types** (CASH, CREDIT\_CARD, DEBIT\_CARD) are marked as `COMPLETE_WITH_PAYMENT`. This confirms both delivery and payment collection.
</Note>

## When to Call

<Steps>
  <Step title="Courier Arrives">
    Courier reaches customer location
  </Step>

  <Step title="Deliver Order">
    Hand order to customer
  </Step>

  <Step title="Collect Payment (if cash)">
    If cash order, collect payment from customer
  </Step>

  <Step title="Confirm Completion">
    Courier confirms delivery in app/POS
  </Step>

  <Step title="Call Endpoint">
    System calls `/complete` to finalize order
  </Step>
</Steps>

## Integration Examples

<Tabs>
  <Tab title="Mobile App (Courier)">
    ```javascript theme={null}
    async function courierCompleteOrder(orderId, photo, signature) {
      const order = await getOrder(orderId);
      
      // 1. Upload proof of delivery
      const proofUrl = await uploadDeliveryProof(photo);
      const signatureUrl = await uploadSignature(signature);
      
      // 2. Complete order
      await completeOrder(order.payment_key);
      
      // 3. Save delivery proof
      await saveDeliveryProof({
        orderId: order.id,
        photoUrl: proofUrl,
        signatureUrl: signatureUrl,
        timestamp: new Date(),
        location: await getCurrentLocation()
      });
      
      showSuccessMessage('Order completed!');
    }
    ```
  </Tab>

  <Tab title="POS System">
    ```javascript theme={null}
    async function posCompleteOrder(order) {
      // Confirm with staff
      const confirmed = await confirmDialog(
        `Complete order ${order.id}?`,
        `Customer: ${order.customer.name}\nTotal: ₺${order.total}`
      );
      
      if (!confirmed) return;
      
      // Complete
      await completeOrder(order.payment_key);
      
      // Update display
      await removeFromActiveOrders(order.id);
      await addToCompletedOrders(order.id);
      
      // Print receipt (if needed)
      if (order.payment_type === 'CASH') {
        await printCourierReceipt(order);
      }
    }
    ```
  </Tab>

  <Tab title="Automatic (GPS)">
    ```javascript theme={null}
    class AutoComplete {
      async monitorDelivery(order, courier) {
        const tracking = await startGPSTracking(courier.id);
        
        tracking.on('arrived', async (location) => {
          // Courier arrived at destination
          if (isNearAddress(location, order.address)) {
            // Wait 2 minutes for handoff
            await sleep(120000);
            
            // Auto-complete
            await completeOrder(order.payment_key);
            
            console.log(`Auto-completed order ${order.id}`);
          }
        });
      }
    }
    ```
  </Tab>
</Tabs>

## Best Practices

<AccordionGroup>
  <Accordion title="Verify Payment Collection">
    ```javascript theme={null}
    async function safeComplete(order) {
      if (order.payment_type === 'CASH') {
        // Confirm cash received
        const cashConfirmed = await confirmCashReceived(order.total);
        
        if (!cashConfirmed) {
          alert('Please confirm cash payment first!');
          return false;
        }
      }
      
      await completeOrder(order.payment_key);
      return true;
    }
    ```
  </Accordion>

  <Accordion title="Record Completion Time">
    ```javascript theme={null}
    async function completeWithTimestamp(order) {
      const completionTime = new Date();
      
      await completeOrder(order.payment_key);
      
      await database.logCompletion({
        orderId: order.id,
        completionTime,
        deliveryDuration: completionTime - order.dispatchTime,
        courierId: order.courierId
      });
    }
    ```
  </Accordion>

  <Accordion title="Customer Feedback">
    ```javascript theme={null}
    async function completeWithFeedback(order) {
      await completeOrder(order.payment_key);
      
      // Request customer feedback (optional)
      setTimeout(() => {
        sendFeedbackRequest(order.customer.phone, order.id);
      }, 300000); // 5 minutes after delivery
    }
    ```
  </Accordion>

  <Accordion title="Analytics Tracking">
    ```javascript theme={null}
    async function completeWithAnalytics(order) {
      await completeOrder(order.payment_key);
      
      // Track metrics
      analytics.track('order_completed', {
        orderId: order.id,
        total: order.total,
        items: order.foods.length,
        deliveryTime: calculateDeliveryTime(order),
        courierId: order.courierId
      });
    }
    ```
  </Accordion>
</AccordionGroup>

## Error Handling

```javascript theme={null}
async function completeOrderSafely(order) {
  try {
    await completeOrder(order.payment_key);
    
    // Success
    showSuccessNotification('Order completed successfully');
    playSuccessSound();
    
  } catch (error) {
    if (error.status === 404) {
      // Order not found
      alert('Order not found. May have been canceled.');
    } else if (error.status === 403) {
      // Invalid order state
      alert('Order cannot be completed in current state');
    } else {
      // Other errors
      console.error('Completion failed:', error);
      alert('Failed to complete order. Please try again.');
    }
    
    // Log for investigation
    await logCompletionError(order.id, error);
  }
}
```

## Post-Completion

<Steps>
  <Step title="Order Archived">
    Order moves to completed/archived status
  </Step>

  <Step title="Courier Available">
    Courier becomes available for next delivery
  </Step>

  <Step title="Customer Notified">
    Customer receives delivery confirmation
  </Step>

  <Step title="Analytics Updated">
    Metrics and reports updated with completion
  </Step>
</Steps>

## Related Endpoints

<CardGroup cols={2}>
  <Card title="On The Way" icon="truck" href="/api-reference/orders/ontheway">
    Previous step: Dispatch order
  </Card>

  <Card title="Order Lifecycle" icon="route" href="/guides/order-lifecycle">
    Complete order flow
  </Card>

  <Card title="Get Current Orders" icon="list" href="/api-reference/orders/get-current">
    Completed orders won't appear here
  </Card>
</CardGroup>