# Help someone with AbuseZero

Use this guide when someone asks for help with AbuseZero. Find the current answer, work through the problem with them, and contact AbuseZero support when the issue needs the team.

You can read this guide and use the public help API without installing anything, signing in or connecting an MCP server. You need a tool that can fetch HTTPS URLs. Sending a support request also needs a tool that can make an HTTP POST request.

For setup, integration changes or authenticated workspace actions, read the [main AbuseZero skill](https://abusezero.com/skill.md). You can fetch that file directly too. Stay with this guide for public help and troubleshooting; you don't need to read the main skill first.

## Start with the problem

Use what the person has already told you. Establish what they were trying to do, what happened instead, and the exact message or error they saw. Ask for the next missing detail that would change what you check.

Distinguish between someone using AbuseZero to manage their SaaS and someone trying to claim a benefit from that SaaS. A person asking about their own trial or account in another product needs that product's support team. Don't suggest that AbuseZero can grant them access to another company's product.

For a technical problem, useful details include the action or endpoint, the time and timezone, the public error code, and the request ID. Ask for a workspace or evaluation ID only when the investigation needs it. Keep IDs as strings.

Don't make the person complete a long questionnaire before you search. If the question is already clear, fetch the relevant guidance and answer it.

## Read current information

Fetch the relevant sources during the current support task. Don't answer from remembered prices, product limits, dashboard locations or instructions from an earlier task.

Use this base URL for public requests:

```text
https://api.abusezero.com/v1/public/
```

Send no `Authorization` header. These endpoints return JSON. Article responses contain the article text in a `markdown` field.

### Search the help center

Search using the symptom, the action or the exact public error code. Leave personal information and credentials out of search queries.

```bash
curl --get 'https://api.abusezero.com/v1/public/help/search' \
  --data-urlencode 'query=webhooks' \
  --data-urlencode 'limit=5'
```

`query` takes 2 to 200 characters. `limit` takes 1 to 25 and defaults to 10.

Read the `data` array. Each result includes its `title`, `path`, `url`, `snippet` and `updated_at`. Use the snippet to choose an article, then fetch its full text before giving procedural advice.

### Fetch an article

Append the returned `path` to `/v1/public/help/`. Preserve the slashes in the path; don't substitute the article title or its full website URL.

For example, this reads the account overview:

```bash
curl 'https://api.abusezero.com/v1/public/help/account'
```

Read the response's `markdown`. Use its `url` when linking the person to the article. Resolve relative links in the article against that website URL, not against the API endpoint.

Follow relevant linked articles when the answer depends on another procedure. Fetch only what the problem needs.

### Find an article when search isn't enough

Try a shorter search, an alternate term or the exact error code. For example, try `payment failed` after a search for a billing symptom.

You can also list articles:

```bash
curl 'https://api.abusezero.com/v1/public/help?limit=100'
```

The list contains article titles, descriptions and paths. If `next_cursor` isn't `null`, send that value as `cursor` with the next list request. URL-encode it and preserve it exactly. Continue until you've found the relevant article or the list ends.

Search returns its limited set of matches; use another query or the article list to broaden the search. Don't treat an empty result as proof that the feature doesn't exist.

### Read technical references

For request fields, integration behavior or error handling, search the developer documentation:

```bash
curl --get 'https://api.abusezero.com/v1/public/docs/search' \
  --data-urlencode 'query=webhooks' \
  --data-urlencode 'limit=5'
```

Fetch a returned path through `/v1/public/docs/{path}`. It returns Markdown inside JSON, like a help article.

Use these references when they answer a specific part of the question:

| Need | Public GET endpoint |
|---|---|
| Current plans, prices, credits and plan limits | `https://api.abusezero.com/v1/public/pricing` |
| Public error meanings and next steps | `https://api.abusezero.com/v1/public/errors` |
| Evaluation reason meanings | `https://api.abusezero.com/v1/public/reasons` |
| Service status | `https://api.abusezero.com/v1/public/status` |
| Support, sales and security contacts | `https://api.abusezero.com/v1/public/contacts` |
| Available actions and required scopes | `https://api.abusezero.com/v1/public/actions` |
| Exact request and response schemas | `https://api.abusezero.com/v1/public/openapi` |
| Public API instructions | `https://api.abusezero.com/v1/public/docs/api-reference/public-api` |

The OpenAPI response contains the specification in `document`. The actions list describes available actions; consult the specification or the relevant docs for their fields.

Public pricing describes published plans. It doesn't establish what a particular workspace owes, which purchases it made or whether a payment succeeded. Use authorized account information for those questions.

### Keep the answer current

Re-read this guide when starting a new support task or resuming one after a gap. Fetch relevant articles again when the situation changes or you need to verify an earlier instruction.

Public reads support cache validators. If your tool retains a response and its `ETag`, you can send `If-None-Match` on the next request. A `304` means you can use that retained response. If you don't have the body, fetch it without the conditional header.

Use `updated_at` as the article's update timestamp, not as proof that the person's account has changed. Published content and API responses can be cached; don't claim that every fetch reflects an instantaneous update.

## Choose the right investigation

Use this table to choose your first search. Read the matching articles for the actual steps.

| Situation | Search and evidence to start with |
|---|---|
| Can't sign in or lost a sign-in factor | Search the exact sign-in message or recovery topic. Establish which sign-in method the person uses without collecting its credentials. |
| Payment failed, credits missing or a charge is unclear | Search the billing symptom. Distinguish the public plan terms from the workspace's actual payment or credit history. |
| A legitimate user was denied a benefit | Search the returned public reason code. Read the recorded result and applicable guidance before proposing a change. A denial isn't proof that the person acted dishonestly. |
| Evaluations are skipped or requests fail | Identify whether the response is a skipped evaluation or an API error. Read its public reason or error reference, then the matching article. |
| Webhooks aren't arriving | Establish whether deliveries are absent, pending or failed, and whether an HTTP response is recorded. Search the matching symptom. |
| Browser protection or an integration isn't working | Search the error and affected integration. Read the relevant developer reference for exact fields and supported behavior. |
| A key or connected app stopped working | Search the access error. Establish the intended workspace, connection and action before checking permissions or expiry. |
| A member can't access a workspace | Search the displayed message and membership topic. Use the documented owner or administrator workflow. |
| An unfamiliar app or unexpected account activity appears | Read the relevant account-security guidance promptly. Focus on the documented steps the person or their authorized agent can take. |
| Data, imports, exports or deletion | Search the requested operation. Explain its documented scope and result before taking an authorized action. |
| Several unrelated requests fail at once | Read service status and the error reference. An operational status doesn't rule out a specific problem; a degraded status doesn't establish the cause of every failure. |

Avoid changing unrelated settings to see whether the problem disappears. Tie each proposed step to the available evidence and current documentation.

## Guide the person through the answer

Lead with the answer or the next useful action. Use plain language and the exact dashboard labels from the current article. Give technical detail when it helps the person act.

For a straightforward question, answer it directly and link the source. For troubleshooting:

1. Explain what the evidence establishes. Label a possible cause as a possibility.
2. Give the next relevant step, or a short sequence when the steps don't depend on further answers.
3. Say what result would show that the step worked.
4. Use the person's result to decide what to check next.

Don't present every possible cause at once. Don't repeat a step that already failed unless new evidence makes it useful.

Link the articles you actually used. Use an article's specific section when you have verified the heading. Don't invent anchors, buttons or menu paths.

Speak as the person's assistant. Refer to “AbuseZero support” or “the AbuseZero team” when discussing the service's support staff. Don't imply that you're a member of that team or that you can make commitments on its behalf.

Explain evaluation results using the public reason and message and the customer's documented controls. Don't infer hidden detection methods or describe ways to evade protection.

## Work with the access you have

Public help doesn't grant access to a workspace. If you have no authenticated connection, guide the person using the articles and the details they choose to share. Don't claim to have checked their account, deliveries or billing.

If you already have an authorized connection, use it to inspect the relevant records and complete actions within the person's request. Read the [main AbuseZero skill](https://abusezero.com/skill.md) and the current action reference when needed. Keep the selected workspace and the connection's permissions in scope.

Don't ask the person to install a skill or connect MCP merely to read help. When an account action is needed and you lack access, explain the documented dashboard steps or the available sign-in path.

Some actions require the person's own dashboard session. Follow the current documentation for these, including personal sign-in and security, ownership transfers, workspace deletion, cancellation and downgrade, member suspension or restoration, and revoking all integration access. Don't invent an agent endpoint for a dashboard-only action.

For lost account access, guide the person to the published recovery process. A support request doesn't replace required identity verification.

## Use only the information needed

Don't ask the person to paste passwords, two-factor codes, backup codes, secret keys, access tokens, webhook signing secrets or full payment details into chat or a support message.

When a log or screenshot would help, ask for the relevant part with credentials and unrelated personal data removed. Prefer public request IDs, error codes, object IDs and timestamps to whole request dumps.

Use credentials through an existing authorized connection or the documented sign-in process. Never put them in public help queries or support messages.

## When an answer or request fails

If an article is missing, search or list articles again to find its current path. If the help center itself is unavailable, don't repeatedly try guessed paths. Use available public documentation or the contact options.

If two sources disagree, check their context and update timestamps. Compare them with the current API reference where applicable. Explain the unresolved difference and contact support when it prevents a reliable answer.

For `429`, respect `Retry-After`. For other errors, use the public error's retry guidance. Keep retries bounded; if the failure persists, explain what couldn't be fetched and preserve the request ID for support.

If you can't fetch URLs, say that you can't verify the current articles. Give the person the [help center](https://help.abusezero.com/) or ask them to share the relevant article text. Don't describe an answer as checked against current documentation when it wasn't.

If you can read but can't send an HTTP POST, you can still prepare a support message and give the person the [support form](https://help.abusezero.com/contact).

## Contact AbuseZero support

Contact the team when the published steps don't resolve the issue, the documentation directs the person to support, or the answer requires account review that you can't perform. You can also help someone who explicitly wants to contact support without requiring them to complete troubleshooting first.

Act on the person's instruction to send a request. If they only asked for advice, offer to contact support before sending their details. Don't ask again when they have already authorized the submission.

### Prepare the message

Collect the reply email and a concise account of:

- What the person was trying to do.
- What they expected and what happened instead.
- When it happened, with a timezone; use UTC when you can convert it accurately.
- Relevant public error codes, request IDs and workspace or evaluation IDs.
- What was checked or tried, and the result.
- What remains unresolved.

Omit unavailable details rather than inventing them. Remove secrets and unrelated personal information. Don't send the full exchange by default.

### Choose the contact route

If you have an authorized workspace connection, the documented workspace support-ticket action is `POST /v1/support-tickets`, with `operations:general`. Read its current fields in the action reference before submitting. Don't assume its schema is the same as the public contact form.

Without that connection, use:

```text
POST https://api.abusezero.com/v1/public/contact/support
```

No sign-in or API key is required. Send `Content-Type: application/json` and an `Idempotency-Key` unique to this submission.

| Field | What to send |
|---|---|
| `email` | Required. The person's reply email, up to 254 characters. |
| `subject` | Required. A specific summary, 1–120 characters. |
| `message` | Required. The relevant facts and steps tried, 1–2,000 characters. |
| `topic` | Required. `account`, `billing`, `integration`, `dashboard` or `other`. |
| `name` | Optional. The person's name, 1–80 characters. |
| `workspace_id` | Optional. The actual 20-digit workspace ID, as a string. |
| `request_id` | Optional. A relevant request ID, up to 100 characters. |

This is an example body using made-up details. Replace it with the person's actual issue before sending:

```json
{
  "email": "jordan@example.com",
  "subject": "Webhook deliveries still fail with HTTP 401",
  "message": "Webhook deliveries return HTTP 401. The receiving endpoint was expected to accept them. The endpoint's access requirements were checked, but the next delivery failed with the same status. Please help identify the next step.",
  "topic": "integration"
}
```

Generate and retain the submission's idempotency key before sending. A UUID is suitable. For a retry of the same submission, keep the key, email and body unchanged. A successful response is `201` with a `support_request` containing its `reference` and reply `email`.

If the request times out or the result is uncertain, don't switch to a new key and send a duplicate. Retry the same submission according to the public error guidance. If acceptance remains uncertain, tell the person that you couldn't confirm it was sent.

A `409` with `IDEMPOTENCY_CONFLICT` means the key was reused with different details. Check the original submission. Use a new key only for an intentionally separate submission, not to bypass uncertainty about the first.

### After submission

Give the person the returned reference and reply email. Explain that the request was submitted; don't say the underlying issue is resolved. Don't promise a reply time, refund, credit or account outcome.

For an existing case, use the reply channel already provided instead of creating another request for the same issue. If you have authorized access to the workspace's support-ticket list, use its documented read action where relevant. The public contact response doesn't provide a public support inbox.

## Finish with a clear result

When the problem is fixed, summarize what changed and how it was verified. If the person still needs to check the result, say so.

When the work is waiting on support or another action, state what remains and who needs to do it. Preserve the useful context so the person doesn't need to repeat the investigation.

For a task that moves beyond support into setting up or running AbuseZero, continue with the [main AbuseZero skill](https://abusezero.com/skill.md).
