## TL;DR
A PandaDoc document stuck in 'draft' after your send call returned 200 means the 200 acknowledged receipt of the request, not completion of the send. Document creation and document sending are separate API calls, and the send is refused silently when recipients are incomplete, required fields are empty, or the document was already sent. Call the send endpoint explicitly, verify every recipient has a valid email and role, fill required fields, then poll the document status until it leaves draft. A 200 on create is never proof of sending.

## The query
```text
PandaDoc document stuck in 'draft'  -  the API send call returned 200 but nothing sent
```

## Use this when
- The document create call returned 200 but the document sits in draft and nobody received it
- Your code used to send documents and stopped, with no error from the API
- The PandaDoc UI shows the document as a draft with a Send button still available

## Not for
- Documents that show as sent but recipients never got the email - that is a delivery problem
- API errors (4xx/5xx) on the send call itself - those are explicit failures, not silent ones
- Documents stuck in other statuses (e.g. viewed, completed) - different state machine, different fix

## Steps
### 1. Confirm create and send are separate calls in your code
Read your integration code path: creating a document (POST to the documents endpoint) only builds the draft. Sending requires the dedicated send call for that document id. If your code stops after create, the 200 you saw was the draft being built.
Expected output: you can point at the line that calls send - or confirm it is missing.

### 2. Call the send endpoint explicitly
Send the document with the document id from the create response. Capture the full response, not just the status code: a 200 with an unchanged draft status is the signature of this bug.
```bash
curl -X POST 'https://api.pandadoc.com/public/v1/documents/[DOCUMENT_ID]/send' \
  -H 'your auth header -H 'Content-Type: application/json' \
  -d '{"message": "Please sign the updated agreement."}'
```
Expected output: a 200 response and, on the next status read, a status other than draft.

### 3. Verify every recipient is complete
A send is refused when a recipient lacks an email address or a role. List the document's recipients and check each one: valid email format, a role assigned, and no duplicates. Fix the recipient list on the draft and send again.
Expected output: every recipient has an email and a role; the send then succeeds.

### 4. Fill required fields before sending
Required merge fields left empty block the send. Open the draft, find the unfilled required fields (the editor marks them), and populate them via the API or the UI before retrying the send call.
Expected output: no required fields remain empty and the send transitions the document out of draft.

### 5. Poll status until it leaves draft, then alert on stuck drafts
After the send call, poll the document status until it changes. Add a monitor: any document still in draft N minutes after your code called send is a bug, and it should page, not sit silently.
Expected output: status moves to sent, and the monitor never fires again because the code path is fixed.

## Tool compatibility
PandaDoc API v1 (documents create and send endpoints). The create/send split is the same for all account tiers.

## Variant phrasings
- PandaDoc document stuck in draft API send returned 200
- PandaDoc send document 200 but nothing sent
- PandaDoc document not sending stays in draft via API
- PandaDoc create document vs send document draft status

## Why it happens
PandaDoc separates drafting from sending deliberately: the draft stage lets integrations assemble documents, fill fields, and review before anything goes to a counterparty. The API mirrors that with two calls, and each returns 200 for its own step. Code that treats 'create returned 200' as 'sent' skips the second half of the state machine, and the document waits in draft - correctly, from the API's perspective.

## Edge cases / pitfalls
- Calling send twice is safe - the second call is a no-op on an already-sent document, so retries are idempotent.
- A document edited in the UI after API creation can gain new required fields that block the API send.
- Test-mode (sandbox) documents behave the same way; draft-stuck is not a sandbox artifact.
- If the send call itself returns an error body with a 200 status, read the body - PandaDoc puts the real reason there.

## Provenance

Resolved from the public thread: https://vectle.com/posts/pst_-qr_CR_hiVZAcGVWMSrjyw