Get help
Write to support Open a request in the console
Write to support@galon.ai from the e-mail address of your account. For an API error, include the X-Request-Id header of the error response and the error code. Signed in, you can also open and follow a request from Support in the console.
Response times
We aim to give a first response within:
| Priority | Definition | First response |
|---|---|---|
| P1 | A service is unusable in production | 4 hours, every day from 08:00 to 20:00 UTC |
| P2 | A service is seriously degraded | 1 business day |
| P3 | A question or a minor problem | 2 business days |
| P4 | A request for information or a suggestion | 5 business days |
Business days and hours, for P2 to P4: Monday to Friday, 08:00 to 18:00 UTC. P1: every day, at the hours shown in the table.
For billing, privacy or legal questions, write to contact@galon.ai.
Documentation · Service Level Agreement · Contact · Report illegal content · Abuse: abuse@galon.ai
Help centre
Answers by topic: open a topic, then a question.
Galon Mail
Help for Galon Mail, the API and SMTP relay that send your application's transactional email from your own domain. It covers setup, keys, limits, delivery status, webhooks and the most common errors.
How do I send my first email with Galon Mail?
1. In the console, open Mail > Plans and activate a plan (the Free plan is available). 2. Open Mail > Domains, add the domain you send from, publish the DNS records it shows at your DNS host, then click Verify now. 3. Create an API key with the mail:send scope in a live project. 4. Send POST /v1/emails with the headers Authorization: Bearer <key>, Content-Type: application/json and a unique Idempotency-Key, and a body with from, to, subject and html or text. The from address must be on your verified domain. A 202 response means Galon accepted the email for sending, not that it was delivered: follow it with GET /v1/emails/<id>. An AI assistant connected to the Galon MCP server can do steps 2 to 4 with the tools add_domain, verify_domain and send_email, but a person still publishes the DNS records.
Which API key and scopes does Galon Mail need?
Sending needs the mail:send scope. Reading your sent emails also needs job:read. When you create a key for Mail, choose its permission: Sending only (sends and reads its jobs, nothing else) or Full access (also manages domains and suppressions). Managing domains or suppressions with a key that is not Full access returns 403 api_key_permission_insufficient; a key without mail:send returns 403 scope_missing. A Sending only key can also be limited to one domain: it then sends only from that domain. For an AI assistant, use one key per application, read it from an environment variable on the server side, and never put it in browser code or logs. The MCP tools list_domains, add_domain, verify_domain and the suppression tools need a Full access key.
What is the difference between test and live keys for Galon Mail?
Keys start with gln_test_ or gln_live_ and belong to a test or a live project. Galon Mail sends real email with live keys only: a test key sent to POST /v1/emails returns 403 test_key_not_allowed. Create a live key in a live project to send. If your account runs in a sandbox sending mode, the opposite applies and a live key returns 403 live_key_not_allowed. The MCP tool get_status (or GET /v1/tools) tells you the environment and sending mode of the key you use. In your own tests, mock the HTTP call: never send real email from automated tests.
Can I send before my domain is verified?
No. Until a sending domain of your project is verified, POST /v1/emails returns 409 mail_no_verified_domain, and the SMTP relay accepts your credentials but refuses the message at MAIL FROM with 550 5.7.1. Add and verify your domain in Mail > Domains, then retry. You can create your mail:send key before that: it sends as soon as the domain is verified. When available for your account, a shared sandbox domain lets you try sending before your own domain is verified: from an address of the sandbox domain, only to the verified addresses of your account (yours and your members'), within a small quota. Its refusals are mail_sandbox_sender_not_allowed, mail_sandbox_recipient_not_verified and mail_sandbox_quota_reached, and the way out is always the same: verify your own domain.
What are the limits of Galon Mail?
At the time of writing, the Free plan includes 3,000 transactional emails a month and 100 a day, transactional email only, with hard limits and no overage. Each recipient (to, cc and bcc) counts as one email. Per request: at most 50 unique recipients, 10 attachments, 25 MB per message once encoded, attachments included (about 18 MB of files; a larger message is refused before 202 with email_too_large), and scheduled_at at most 72 hours ahead; POST /v1/emails/batch takes 1 to 100 messages without attachments. Paid plans have their own volumes, shown in Mail > Plans; on a paid plan, emails beyond the plan's volume are charged to the balance at the overage price. When the Free daily or monthly limit is reached, the email is accepted (202) and then ends with the status failed and the reason mail_daily_send_limit_reached or mail_monthly_send_limit_reached. The current limits are also returned by GET /v1/free-plan and GET /v1/mail/plans.
How is Galon Mail billed? Does sending use my prepaid balance?
Galon Mail is sold as plans counted in emails sent: the Free plan, and paid plans when they are available in your console. Sending is counted against your plan's quotas; it is not charged to the project balance per message. Prices are in US dollars and shown on the pricing page and in Mail > Plans; the exact amount is shown before you pay. Without an active plan, sending returns 409 mail_subscription_inactive: activate the Free plan or a plan in Mail > Plans.
How do I know whether an email was delivered?
POST /v1/emails returns the email id. Read it with GET /v1/emails/<id> (MCP tool get_email) or list with GET /v1/emails (list_emails). The status is one of the email journal values of the API reference: queued, scheduled, sent, delivered, delivery_delayed, bounced, complained, failed, suppressed, opened, clicked, or the value of an email cancelled before sending; failed carries a reason. To be told instead of polling, create a webhook endpoint in the console (Webhooks) and subscribe to the email.* events you need, such as email.delivered, email.bounced, email.complained, email.failed and email.suppressed. Webhooks are not subscribed by default: you choose each event.
What data does Galon Mail keep, and how do I delete a domain or a suppression?
The content of an email (addresses, subject, body, tags) is kept with the email until the Mail retention period ends, then replaced; after that, GET /v1/emails/<id> no longer returns it. The delivery timeline is kept without addresses: each recipient appears only as a keyed hash. To delete a sending domain, call DELETE /v1/domains/<id> with the header Galon-Confirm set to the exact domain name (without it: 428 confirmation_required), or delete it in Mail > Domains. To let an address receive email again, delete it from the suppression list (DELETE /v1/suppressions/<email>); a suppression caused by a complaint cannot be removed (409 suppression_not_removable). Account deletion and data export are covered on their own help pages.
Can I send through SMTP instead of the API?
Yes, when SMTP is shown in your console (Mail overview, SMTP card). Use the host shown there, port 587 with STARTTLS or port 465 with TLS, the username galon and, as password, an API key with the mail:send scope. TLS is required before authentication. The From header and MAIL FROM must belong to a verified domain of the key's account. The same plans, limits and suppressions apply as for the API. A message resent with the same Message-ID by the same key is not sent twice. Repeated authentication failures block the client IP for a while (421 4.7.0).
POST /v1/emails returns 409 with code mail_no_verified_domain, or the SMTP relay answers 235 to AUTH and then 550 5.7.1 "No verified sending domain" at MAIL FROM. In a shared sandbox, 403 mail_sandbox_sender_not_allowed or mail_sandbox_recipient_not_verified, or 429 mail_sandbox_quota_reached.
1. Your key and password are valid: the refusal is about the domain, not the credentials. 2. Open Mail > Domains (or call the MCP tool list_domains) and check that the domain of your from address is listed in the same project as the key and has the status verified. 3. If it is pending or failed, open it and look at the status of each DNS record. 4. If the from address uses another domain, that domain is not verified for this project. Add the domain if it is missing, publish the records shown, then click Verify now (or call verify_domain). Send from an address of the verified domain. In the sandbox, there is nothing to raise: verify your own domain to send to anyone, within your plan's limits.
A sending domain stays pending, or shows failed, after you published its DNS records. Verify now may return 429 verify_rate_limited.
1. Open the domain in Mail > Domains (or get_domain) and read each record: its type, name, value, level (required, recommended, optional) and status. 2. The DKIM TXT record (selector._domainkey) is required: the domain is verified when the public key published in DNS is exactly the one shown. 3. If your DNS zone is a parent of the sending domain, use the name relative to the zone shown for the record, not the full name twice. 4. Two SPF records on the same name make SPF fail: you need one SPF record. The console proposes a merged value that replaces your existing ones, and warns when it goes beyond 10 DNS lookups. 5. DNS changes can take time to propagate; a resolver that does not answer leaves the record pending, never failed. Fix the record at your DNS host with the exact value shown (no extra quotes or spaces), keep only one SPF record, then click Verify now. Verify now is limited to one call per minute: wait the Retry-After delay before trying again.
POST /v1/emails returns 409 mail_subscription_inactive, or the SMTP relay answers 550 5.7.1 "Galon Mail is not active for this account".
No Galon Mail plan is active for this account. Open Mail > Plans: if no plan is shown as active, this is the cause. If you activated a plan a few minutes ago, the account may still be activating (409 mail_account_not_ready, or 451 4.7.1 over SMTP). Activate the Free plan or a plan in Mail > Plans, then retry. While the account is activating, retry in a few minutes with the same Idempotency-Key.
POST /v1/emails returns 401 api_key_invalid or api_key_missing, 403 scope_missing, 403 test_key_not_allowed or live_key_not_allowed; or the SMTP relay answers 535 5.7.8.
1. 401: the Authorization header is missing, or the key is revoked, expired or mistyped. Check that your server reads the key from its environment variable. 2. 403 scope_missing (SMTP: "This API key lacks the mail:send scope"): the key does not have mail:send. 3. 403 test_key_not_allowed: the key starts with gln_test_; Galon Mail sends with live keys. 4. 403 api_key_permission_insufficient on /v1/domains or /v1/suppressions: the key is not Full access. Create a new key with the scope and permission you need, in the right environment, in the console; replace the old value in your server's environment, then retry. Revoke keys you no longer use.
An email was accepted (202) but GET /v1/emails/<id> shows bounced, complained, suppressed or failed, or the recipient says nothing arrived.
1. bounced: the receiving server refused the address permanently (unknown address or domain). Galon then adds the recipient to your project's suppression list. 2. complained: the recipient marked the email as spam; the address is suppressed and cannot be removed. 3. suppressed: the address was already on the suppression list (bounce, complaint, unsubscribe or manual), so nothing was sent to it. 4. failed: read failed.reason, for example mail_daily_send_limit_reached or mail_sender_not_allowed (the from domain is not a verified domain of this project). 5. delivery_delayed: the receiving server asked to retry later; wait for the next event. GET /v1/emails/bounce-reasons and the MCP tool list_suppressions help you see the pattern. Fix the address with the recipient, or remove a bounce or manual suppression with DELETE /v1/suppressions/<email> once the address is valid again. Remove addresses that bounce or did not consent from your lists. A high bounce or complaint rate can lead Galon to suspend sending for the account.
Emails end with the status failed and the reason mail_daily_send_limit_reached or mail_monthly_send_limit_reached, or POST /v1/emails returns 429 mail_budget_exceeded.
1. Open Mail > Plans and compare your usage for the day and the month with your plan's limits; remember that each recipient counts as one email. 2. The Free plan has hard limits: nothing is sent beyond them until the next day (UTC) or month. 3. 429 mail_budget_exceeded means a safety limit on Galon's side refused the send. Wait for the next period, or change to a plan with higher limits in Mail > Plans when paid plans are available in your console. For a 429, wait and retry with backoff and the same Idempotency-Key.
Your webhook endpoint receives no email.* events, or the console shows its deliveries as failed.
1. In the console, open Webhooks and check that the endpoint is enabled and subscribed to the email.* events you expect: each event is chosen explicitly. 2. The URL must be public HTTPS on port 443; private networks, other ports and redirects are not allowed (a 3xx answer counts as a failure). 3. Your endpoint must answer 2xx within 10 seconds. A 4xx other than 408, 409, 425 or 429 stops the retries; other failures are retried with growing delays, up to 8 attempts. 4. Open the delivery and its attempts to see the HTTP status received. 5. If your code verifies Galon-Signature, sign timestamp + "." + raw body with your signing secret, before parsing the JSON, and allow 5 minutes of clock difference. Fix the URL or your endpoint, use Send test event to check it, then replay the failed deliveries from the console. After rotating the secret, both signatures are sent for 24 hours: accept either.
Emails show delivered but land in the recipients' spam or junk folder.
1. Open the domain in Mail > Domains: the DKIM record must be verified, and SPF and DMARC should be verified too (they are recommended, not required). 2. Open Mail > Deliverability: it shows delivery, bounce and complaint rates by mailbox provider over 7 and 30 days, with recommendations when a rate is too high. 3. Check that you send only to people who asked for your email, and that the from address and content match your domain and brand. Publish the recommended SPF and DMARC records, clean your lists (remove addresses that bounce or did not consent), and follow the recommendations shown in Mail > Deliverability. Galon publishes DMARC with p=none by default; move to a stricter policy only once your legitimate mail passes.
Starting a broadcast returns 409 with code mail_marketing_dmarc_required, or a marketing email fails with that reason, while transactional email from the same domain is sent normally.
1. Marketing email requires a DMARC record on the sending domain: large mailbox providers require it from bulk senders, and when this rule applies to your account Galon checks it before sending marketing email. 2. Open the domain in Mail > Domains and look at the DMARC line: it must be verified. A missing record, two DMARC records on the same name, or a record without a p= policy all count as not verified. 3. A DMARC record on the parent domain also covers its subdomains. Publish one TXT record at _dmarc.<your domain>, for example v=DMARC1; p=none, keep a single DMARC record per name, then click Verify now on the domain. Start the broadcast again once the DMARC line shows verified. Transactional email needs no change.
Galon Storage
How to use Galon Storage, object storage for your project: buckets, uploads, sharing, billing from your balance, and the errors you are most likely to see. Galon Storage has its own HTTP API (it is not S3-compatible) and stores files in Paris (EU). It is available on request; features marked 'when available' depend on your account.
How do I start with Galon Storage?
Galon Storage is available on request: until it is open to your account, its routes answer 404 not_found, and creating a bucket answers 403 storage_not_open while file storage is not open yet. In the console, Services > Storage shows your usage, your storage tier and your buckets; it is reserved to administrators. With the API: create a key with the storage:write and storage:read scopes, top up the project balance (or, when storage tiers are available for your account, choose a tier: How do storage tiers work and how are they paid), create a bucket with POST /v1/storage/buckets, an Idempotency-Key header and a body {"name": ..., "placement": ...} (send "eu" as placement: every bucket is stored in Paris, EU), then upload files (see How does an upload work). A bucket name has 3 to 63 characters: lowercase letters, digits, dots and hyphens, starting and ending with a letter or a digit; another name returns 422 storage_bucket_name_invalid, a name already used in the project 409 storage_bucket_exists.
Which key scopes does Storage use, and how do test and live work?
Send an API key as 'Authorization: Bearer <key>'. storage:read lists and reads buckets, files, usage, versions and the tier, and creates signed links. storage:write creates buckets, starts and commits uploads, deletes files, restores versions, changes the tier and the public access of a bucket. A key without the scope a call needs gets 403 scope_missing. A key sees only its own project and environment (test or live): a bucket of another project answers 404 storage_bucket_not_found, not 403. Give an AI assistant a key with only the scopes it needs: a storage:write key can change the tier, which is paid from the balance.
How does an upload work?
File bytes never go through the JSON API. 1) POST /v1/storage/buckets/<bucket_id>/uploads with an Idempotency-Key header and {"key", "size_bytes", "checksum"}, where checksum is "sha256:" followed by the 64 lowercase hex characters of the file's SHA-256. The answer holds an upload id (upl_...) and a capability: a URL, the headers to send and an expiry. 2) PUT the exact bytes to the capability URL with exactly those headers before it expires (5 minutes by default). 3) POST /v1/storage/uploads/<upload_id>/commit: the file becomes available and gets its obj_ id. If the capability expired, call step 1 again with the same Idempotency-Key and body to get a fresh one, while the reservation lasts (24 hours by default). An AI assistant can do the same with the MCP tools start_upload and commit_upload, sending the bytes in between.
What are the size limits?
At the time of writing: one upload in a single PUT is limited to 256 MiB by the upload relay (or to the maximum size configured for your storage, if lower). A larger size_bytes returns 413 object_too_large when you start the upload, or 413 storage_multipart_required on the PUT when multipart upload is available for your account; a multipart upload sends a file of up to 50 GiB in parts of 64 MiB. An object key is at most 1,024 bytes. A project has up to 10 buckets by default (429 storage_bucket_quota_exceeded beyond). The total size of your files, older versions included, is limited by your storage tier (see Starting an upload answers 429 storage_tier_limit_exceeded or storage_bytes_quota_exceeded, or 402 storage_tier_required: the tier is full).
How do I download or share a file?
Files are private. GET /v1/storage/objects/<object_id> returns the file's metadata, not its bytes. When signed links are available for your account, POST /v1/storage/objects/<object_id>/links with {"expires_in": <seconds>, "disposition": "attachment" or "inline"} returns a URL that works without a key until it expires, from 60 seconds to 7 days. Anyone with the URL can download the file: share it like a password. Deleting the file revokes all its links. Only safe types (images, PDF, plain text, audio, video) open inline; HTML, SVG and other types download as attachments. When public buckets are available for your account, you can also serve a whole bucket publicly (see A bucket was made public by mistake, or its public address answers 403 storage_public_access_disabled, 404 storage_public_listing_disabled or 429 storage_public_bandwidth_exhausted).
How do storage tiers work and how are they paid?
When storage tiers are available for your account, Storage is paid by tier: at the time of writing 5 GB, 50 GB, 500 GB, 5 TB and 10 TB (decimal units). A tier is paid in advance from your balance for 30 days from the day you choose it; prices are on the pricing page. Moving up takes effect at once and you pay only the difference for the current period; moving down takes effect at the next renewal and is refused if your files already exceed the smaller tier. The tier is a hard limit: an upload that would exceed it is refused, and older versions count. Without a tier, uploads answer 402 storage_tier_required; the console then offers the smallest plan that fits, on the spot. Read and change the tier with GET and PUT /v1/storage/tier ({"tier_id": "50gb"}) or in Services > Storage; an unknown tier_id returns 422 storage_tier_unknown. At the end of a period the tier is renewed from your balance: an upload after the end tries the renewal first, and the scheduled renewal runs in Galon's daily storage process, once a day shortly after 00:20 UTC.
What happens to my files when my balance runs out?
When your balance can no longer pay your storage (day J0), new uploads are refused with 402 storage_balance_insufficient; your files stay readable and you can still delete files and read your usage. Galon's schedule is then: from J14 files are no longer served (402 storage_suspended) and nothing is erased; from J30 they may be deleted, only after notices on J0, J7, J13, J21 and J28 and never earlier than 48 hours after the last notice. A top-up before deletion restores the service, and the days between J0 and the top-up are not charged afterwards. Galon's daily storage process carries out this schedule: it runs once a day shortly after 00:20 UTC and charges the storage of the previous UTC day to the project's prepaid balance. Watch your balance and the notices sent to your administrators.
Does an upload overwrite a file? How do versions work?
No. Uploading to a key that already holds a file creates a new version, and the latest one is current. GET /v1/storage/objects/<object_id>/versions lists the versions and POST /v1/storage/objects/<object_id>/restore makes an older one current again, without copying or deleting anything. Older versions count towards your usage and your tier until they are purged. Galon's policy is to purge a version that is no longer current after at least 30 days (the default at the time of writing); this purge runs in the daily storage process, once a day shortly after 00:20 UTC, so an older version can stay up to a day longer.
How do I delete files and buckets?
DELETE /v1/storage/objects/<object_id> deletes a file: it is no longer listed or served and its signed links stop working; the answer is 202, or 200 if it was already deleted. The MCP tool delete_object does the same and is marked destructive. Galon then erases the stored bytes through its daily storage process, once a day shortly after 00:20 UTC. When bucket deletion is available for your account, DELETE /v1/storage/buckets/<bucket_id> removes an empty bucket (see Deleting a bucket answers 409 storage_bucket_not_empty, even after you deleted its files if it is refused). Galon Storage is not a backup: keep your own copy of anything you cannot afford to lose.
A Storage call answers 401 api_key_missing or api_key_invalid, or 403 scope_missing or tenant_suspended.
1) 401: the Authorization header is missing, or the key is unknown, revoked or expired. 2) 403 scope_missing: the key lacks the scope of this call, storage:read for reads and signed links, storage:write for buckets, uploads, deletions, restores, the tier and public access; check the key's scopes in the console (API keys). 3) 403 tenant_suspended: the account is suspended. 4) A 404 on a bucket you can see in the console usually means the key belongs to another project or environment (test or live). Create a key with the missing scope in the console (API keys, New key), then retry the same call with it. For an AI assistant, give it a key with only the scopes it needs.
404 storage_bucket_not_found or storage_object_not_found for a bucket or file you expect to exist.
The id is unknown to this key: a malformed id (bkt_ or obj_ followed by 32 hex characters), a bucket or file of another project or environment, a deleted file, or a file whose upload was never committed (the upload id upl_... is not a file id; the obj_ id exists only after the commit). List with GET /v1/storage/buckets and GET /v1/storage/buckets/<bucket_id>/objects using the same key. Use an id returned by the list calls (or by the MCP tools list_buckets and list_objects), and check that the key belongs to the right project and environment.
Deleting a bucket answers 409 storage_bucket_not_empty, even after you deleted its files.
Bucket deletion is available only on some accounts; elsewhere the route is not offered. A bucket counts as empty only when no file in it still has stored bytes and no upload started less than its reservation time ago (24 hours by default). A deleted file keeps its bytes until Galon's daily storage process erases them, once a day shortly after 00:20 UTC, so a bucket whose files you deleted can still answer 409 until that process has run. List the bucket's files to see what remains. 412 storage_precondition_failed means the bucket is not in a ready state. Delete the remaining files (DELETE /v1/storage/objects/<object_id>), let uploads in progress be committed or expire, then retry the bucket deletion.
413 object_too_large when you start an upload, or 413 storage_multipart_required on the PUT.
size_bytes is above the largest upload this storage accepts. At the time of writing a single PUT is limited to 256 MiB by the upload relay; when multipart upload is available for your account, larger files (up to 50 GiB) must be sent in parts on the same capability. 422 size_bytes_invalid means size_bytes is not a non-negative integer. Split or compress the content, or use the multipart upload when your account offers it, then start a new upload with a new Idempotency-Key.
Starting an upload answers 429 storage_tier_limit_exceeded or storage_bytes_quota_exceeded, or 402 storage_tier_required: the tier is full.
Your files, their older versions and the uploads in progress, plus this upload, would exceed your tier or your project's storage quota. GET /v1/storage/usage shows committed, reserved and pending-deletion bytes; GET /v1/storage/tier shows the current tier and its size. Uploads started but not committed hold their size until they expire. 402 storage_tier_required means the project has no tier yet. Move to a larger tier (PUT /v1/storage/tier, or Services > Storage in the console): the change is immediate and you pay the difference for the current period from your balance. Or delete files you no longer need and check the usage again. Then start the upload again with the same Idempotency-Key and body.
Uploads answer 402 storage_balance_insufficient, or reads, lists and links answer 402 storage_suspended: files are no longer served.
Your balance no longer covers your storage. storage_balance_insufficient: uploads are blocked, files remain readable. storage_suspended: under Galon's schedule, from 14 days after the balance ran out (J14), nothing is served, and nothing is erased yet; deleting files and reading usage still work. Check the balance in the console (Usage & billing, Balance tab) and the notices sent to your administrators. Galon's daily storage process runs this schedule once a day shortly after 00:20 UTC; it also charges the storage of the previous UTC day to the project's prepaid balance. Top up the balance in the console. A top-up that covers the current period again restores uploads and reads. Under the schedule, files may be deleted from J30 after five notices, so act before then.
A signed link answers 410 storage_link_expired, 404 storage_link_revoked or 403 storage_link_invalid; or creating a link answers 409 storage_object_not_available or 422 storage_link_duration_invalid.
410: the link passed its expires_at. 404 storage_link_revoked: the file was deleted, or its deletion requested, after the link was made. 403: the URL was cut or altered; links are long, so check that nothing truncated it. 409 on creation: the file is not available (its upload is not committed). 422: expires_in must be an integer from 60 to 604,800 seconds (7 days). Create a new link with POST /v1/storage/objects/<object_id>/links and share the new URL. A link cannot be extended: for files that must stay reachable, create links when they are needed, or use a public bucket when it is available for your account.
A bucket was made public by mistake, or its public address answers 403 storage_public_access_disabled, 404 storage_public_listing_disabled or 429 storage_public_bandwidth_exhausted.
Public buckets are available only on some accounts. GET /v1/storage/buckets/<bucket_id>/access shows whether a bucket is public. A public bucket serves each file, by its exact key, to anyone who has the address; it never lists its content and never accepts writes (405 storage_public_read_only). 403 storage_public_access_disabled: the bucket is private, or private again. 404 storage_public_listing_disabled: the address is the root or ends with /. 429: the project used its daily public bandwidth (UTC day); Retry-After gives the seconds until midnight UTC. HTML and unknown types download as attachments by design. To close a bucket, send PUT /v1/storage/buckets/<bucket_id>/access with {"public": false, "confirm": "disallow"}: it applies to the next request, and browsers may keep a copy for up to 60 seconds. If secrets or personal data were exposed, rotate those secrets and delete the files. To open a bucket you must send {"public": true, "confirm": "allow"}; without the exact confirmation you get 422 storage_public_confirmation_required and nothing changes.
The PUT to the capability URL answers 412 storage_precondition_failed, 422 storage_checksum_mismatch or 403 storage_forbidden.
412: the capability expired (5 minutes by default), a header differs from the ones the capability returned (Content-Length must equal size_bytes, the checksum header must match, If-None-Match must be *), or the reservation itself expired. 422 storage_checksum_mismatch: the bytes sent do not have the SHA-256 declared when the upload started. 403 storage_forbidden: the capability URL was altered or truncated. Recompute the SHA-256 of the exact bytes. If they match what you declared, call the upload start again with the same Idempotency-Key and body to get a fresh capability, PUT with exactly the headers it returns, then commit. If the content changed, start a new upload with a new Idempotency-Key.
Galon Domains
Galon Domains lets you search, register, renew and manage domain names. A domain is paid by card on a secure payment page, never from your project balance. This help covers search and quotes, purchase by card, DNS records, transfers out and renewal.
How do I start with Galon Domains?
In the console, open Services > Domains. The page has the tabs Portfolio, Orders and Notices, plus Buy a domain when it is open for your account. In Buy a domain, type a name such as example.com: Galon checks whether it is free, then shows its price and its yearly renewal price before you order. Every action works on the project selected in the console. If Domains is not open for your account, the console does not show it and the API answers 404 not_found. An AI assistant connected to the Galon MCP server can check names (check_domain), price them (quote_domain, get_domain_quote) and list your domains, orders and notices (list_owned_domains, list_domain_orders, list_domain_notices).
Which API key scopes do I need, and what can an AI assistant do on its own?
Reading and pricing need no approval: domain:lookup (POST /v1/jobs with type domain.lookup), domain:quote (type domain.quote, then GET /v1/domain-quotes/<id>), domain:read (GET /v1/domain-portfolio, /v1/domain-orders and /v1/domain-notices) and job:read to read a job result with GET /v1/jobs/<id>. DNS reads use domain:dns_read and DNS changes domain:dns_write. Buying and renewing a domain spend money, so a person always approves them: either in the console, or after an app connected with OAuth calls the MCP tool request_approval, which returns a console_url for the person to open. A key that sends type domain.purchase to POST /v1/jobs gets 403 approval_required. Approval requests from an API key get 403 approval_requires_app_connection. A missing scope returns 403 scope_missing: create a key with that scope in the console, then retry.
How is a domain paid?
A domain is paid by card, on a secure payment page opened from the console, in USD at the price of your quote; Galon never pays a domain from the prepaid balance. The registration starts only once the payment is confirmed. If the payment is confirmed but the registration fails, or does not start within 24 hours, the full amount is refunded to the same card automatically: you need not ask. You see the order, its status and its receipt in Domains > Orders. If card payment is paused on Galon's side, the order is refused with 503 domain_payment_unavailable and nothing is charged.
Can I buy a domain from a Test project?
No. Checking names and reading quotes charge nothing, but a real purchase or renewal is made in a Live project. In a Test project the order is refused with 409 domain_wallet_project_not_live and nothing is charged. Choose or create a Live project in the console, then order again from it.
How long is a price valid, and can I buy a premium name?
A quote is short-lived: at the time of writing it expires after at most 30 minutes; read expires_at on the quote. An order uses the exact price of the quote you saw. If the quote expired or was already used, the order is refused and the console asks for a new price: get a new quote, then order again. A premium name is sold at its own price only when your console shows that price with a confirmation step, and only after you confirm that exact amount; otherwise the console says that the premium name cannot be bought here. The extensions shown next to your search are suggestions to check, not a promise that the name is free.
How do I edit the DNS records of my domain?
Open the domain from Portfolio, then its DNS records. When DNS editing is open for your account, you can add, edit and delete records, or import a zone file; otherwise the records are read-only. Accepted types: A, AAAA, CAA, CNAME, HTTPS, MX, NS, SRV, SSHFP, SVCB, TLSA and TXT. The TTL is between 60 and 86400 seconds (3600 by default), and one change carries 1 to 100 records. The SOA and the name servers at the root of the domain are managed by Galon and cannot be edited (domain_dns_nameservers_managed). With an API key, read the records with POST /v1/jobs type domain.dns.read (scope domain:dns_read) and change them with POST /v1/domain-actions type domain.dns.apply (scope domain:dns_write). A refused record returns 422 domain_action_invalid with field set to name, ttl or value.
Can Galon host the DNS of a domain I bought elsewhere?
Yes, when your console offers DNS for a domain bought elsewhere. Add the domain there: Galon creates its zone and shows it as Waiting for delegation. At the registrar where the domain is registered, replace its name servers with the Galon name servers shown on the page. Galon reads the public delegation again at most every 5 minutes; the change can take up to 48 hours to be seen everywhere. At the time of writing a project can hold up to 50 such zones. A name already set up in another Galon account is refused with 409 dns_zone_claimed, and a domain already in your portfolio is managed from its own page. Removing the zone stops Galon from serving its records at once.
How does renewal work?
Renewal is manual, on request: on the domain page, Renew now renews the domain for one more year at the renewal price shown, paid by card. At the time of writing Galon does not renew a domain automatically, and it never renews without a successful payment. A domain is registered one year at a time. Notices shows expiry notices 90, 30, 7 and 1 days before expiry. A domain that expires may be lost: renew it before its expiry date.
Can I transfer a domain to Galon, or away from Galon?
Transferring a domain to Galon is not available online yet. Transfer out: on the domain page, Transfer out unlocks the domain and shows its authorisation code once; give it to the new registrar. It is refused within 60 days of a purchase or of a previous transfer. If your console does not offer Transfer out, write to support@galon.ai to request the code.
Search says the name is not available, or that it is a premium name that cannot be bought here; or placing the order returns 409 `domain_unavailable`.
1. Read the result of the lookup job (get_job, or GET /v1/jobs/<id>): available false means the name is registered; premium true means the registry sells it at a premium price. 2. A 409 domain_unavailable at checkout or at transfer means the name is already held in another Galon project or account; Galon does not say by whom, and nothing was reserved. 3. If no price is shown, the price could not be read this time. Choose another name or another extension: the search suggests the same name under other extensions. Buy a premium name only if your console shows its price with a confirmation step. If no price was shown, search again in a moment.
In Orders, an order stays open without reaching Completed, or ends as Failed.
1. An order appears once the card payment is confirmed; the registration then runs in the background. 2. Failed means the registration did not happen: the payment is refunded to the same card automatically. A registration that did not start within 24 hours ends the same way. 3. If the registry's answer was lost, the order stays open while Galon reads the registry again (after 30 seconds, 2 minutes, 10 minutes, then every hour). Galon never guesses a charge or a refund. Follow the order in Orders, with list_domain_orders or with GET /v1/domain-orders. For a failed order, order again with a new quote: the refund of the failed one is automatic. For an order still open, wait and read it again. Do not order the same name again while the first order is open.
Placing the order returns 409 `domain_wallet_project_not_live`, or 503 with `domain_reseller_balance_insufficient` or `domain_payment_unavailable`.
409: the project is a Test project, where nothing is charged. 503: purchases are paused on Galon's side; your card was not charged. 409: place the order from a Live project. 503: retry later with exponential backoff.
Placing the order returns 422 with a `field`, or the console highlights a field of the domain holder form.
The holder details, or the registry data that the extension requires, were refused before anything was reserved. field names what to fix, for example address.country, address.state or company_name for an extension that requires a local presence or a company. Some extensions require extra registry data (registry_data_required) or a minimum registration period. The phone number needs its country calling code, for example +225. Correct the named field (a valid email address, the phone number with its country calling code, the country, the data the extension asks for), then place the order again.
A DNS record was saved, but the old value is still answered; or a domain bought elsewhere stays Waiting for delegation.
1. Read the zone again on the domain page: if the record is there, Galon serves it. 2. Resolvers that cached the old value keep it until its TTL ends: up to the TTL of the old record, 3600 seconds by default and 86400 at most. 3. For a domain bought elsewhere, Waiting for delegation means the public DNS does not yet point to the Galon name servers: check the name servers set at your registrar. Galon reads the delegation again at most every 5 minutes; a change of name servers can take up to 48 hours to be seen everywhere. Wait for the old TTL to pass. Before a planned change, lower the TTL of the record (60 seconds at least) and wait one old TTL before changing the value. For a delegation, set exactly the Galon name servers shown on the page, at your registrar. On 503 dns_zones_unavailable, retry later.
Galon Mail refuses to send with `mail_no_verified_domain`, or a Deploy custom domain stays pending with `deploy_domain_txt_missing` or `deploy_domain_routing_missing`.
Mail and Deploy verify a domain by reading its public DNS records. Owning the domain in Galon Domains does not add these records for you. Mail needs the records listed on the domain page in Mail > Domains. Deploy needs a TXT record that proves ownership and a CNAME or A record for routing. Compare each record in the domain's DNS records with the exact name and value that the service shows. Add the missing records in the DNS records of the domain (or at your DNS host if the domain is elsewhere), wait for the TTL, then verify again in Mail > Domains or in Deploy.
Transfer out returns 409 `domain_transfer_out_locked_60_days`, 409 `domain_transfer_out_status`, 422 `domain_transfer_out_refused` or 429 `rate_limited`.
domain_transfer_out_locked_60_days: the domain was bought or transferred to Galon less than 60 days ago; eligible_from gives the date. domain_transfer_out_status: the domain is pending, already in a transfer, in redemption or suspended by the registry; active domains and expired domains still in their grace period can leave. domain_transfer_out_refused: the registry refused to give the code. 429: more than 5 requests in an hour on the account. Wait until eligible_from. For a status refusal, wait until the domain is active again (renew it if it expired). On 429, wait the Retry-After delay. The code is shown once: copy it at once and give it only to the new registrar. The domain stays unlocked.
Notices shows Expiration approaching, or Renew now returns an error.
Renewal is manual: a domain is renewed only when you click Renew now and the card payment succeeds. Stops have their own code: domain_renewal_price_changed (the price rose above the price you accepted), domain_renewal_quote_expired (the price shown expired), domain_renewal_expired (the domain already expired and no longer renews from the console). Click Renew now on the domain page and pay by card. For a changed price, accept the new price shown on the domain page. For an expired domain, contact support at once.
Galon Functions
Galon Functions runs your JavaScript functions: each function is an ES module that answers HTTPS requests at its own address. This help covers deploying, keys and environments, limits, revisions and rollback, logs, the prepaid balance and the errors you are most likely to meet.
How do I deploy my first function?
In the console, open Functions, select Create function (or start from a template such as Hello world or JSON API), give it a name, paste your code, choose an API key of the project that carries functions:deploy, then select Deploy function. The page follows the deployment (Send code, Queued, Deploying) and shows the function's address once it is live. Through the API: upload the module with POST /v1/functions/sources (Content-Type application/javascript), then deploy it with POST /v1/functions/deployments, an Idempotency-Key header and a JSON body with name, source_ref, source_sha256, environment and compatibility_date. The answer gives a job id and the function's address; follow the job with GET /v1/functions/jobs/<job_id> until its status is final. Functions is opened account by account: while the console says Functions is being set up, you can prepare your code but not deploy it.
Which API key and scopes does Functions need?
Uploading code, deploying and deleting need a key with the functions:deploy scope. Reading a job and the price list (GET /v1/functions/pricing) needs job:read. A key without the scope gets 403 scope_missing: create a key with functions:deploy in the console and retry. In the console, deployments also run under a key of the project that you choose by its name; its secret is never asked for. An AI assistant connected by OAuth cannot be granted functions:deploy at the time of writing: a person deploys from the console, or the assistant calls the API with a key that a person created for it.
How do test and live work for functions?
A function belongs to one environment, test or live, the environment of the key that deploys it. Test and live functions of the same account run in separate isolated environments, so code you test never sees what runs in live, and they have different addresses. In an API call, the environment field must match the key's environment: otherwise the call returns 403 functions_environment_mismatch. In the console, rolling back with a key of another environment than the revision returns 409 functions_environment_mismatch. Use a key of the right environment, created in the console.
What code can a function run?
A function is one JavaScript ES module with a default export that has a fetch handler, for example export default { async fetch(request) { return new Response('ok'); } }. The file must be UTF-8 text; WebAssembly and the older service-worker format are refused (functions_module_not_js). At the time of writing a module can be up to 1 MiB. Outgoing requests from your code go to public websites over HTTPS on port 443, by host name; plain HTTP, IP addresses, private networks and other ports (25 included) are refused. Function names use lowercase letters, digits and dashes, start with a letter, and are 40 characters at most. Variables and secrets are not passed to functions yet: keep keys out of your code until then.
What are the limits on duration, memory and size?
At the time of writing, and subject to change: one invocation can run for 30 seconds; beyond that it is stopped and answered with 504. The functions of one account and environment share an isolated environment with 256 MiB of memory and half a CPU by default. A request body can be up to 10 MiB (413 functions_request_too_large beyond) and a response up to 32 MiB. After about 5 minutes without requests the environment is put to sleep: the next request wakes it up and can be slower (cold start). Functions runs in a single region; it is not a global delivery network.
How is Functions paid, and what happens when my balance runs out?
Functions is prepaid from the project balance; prices are counted per million requests and per million CPU milliseconds and are shown on the pricing page (and by GET /v1/functions/pricing). There is no debt. When the balance is used up, new deployments and rollbacks are refused with 402 functions_balance_exhausted, and with 402 functions_account_suspended after a longer period. Deleting a function is always allowed: it stops consumption. Your functions and settings are kept. Top up the balance, then deploy again.
How do revisions and rollback work?
Each deployment of a function creates a revision. In the console, open the function, then Revisions: select Roll back on an earlier revision to deploy its code again. The function's address does not change, and the revision you replaced stays in the list so you can roll forward again. A rollback follows the same checks as a deployment (key, scope, prepaid balance). 409 functions_operation_in_progress means another deployment of this function is still running: wait for it to finish. 409 functions_revision_already_current means that revision is already live.
Where do I see logs and invocations?
Open the function in the console. The Logs tab shows the latest execution lines, newest first: each request and each console.log, console.info, console.warn and console.error line of your code, filtered by level (up to 200 lines per read). The Overview tab shows invocations, errors, response times (p50 and p95) over 1 hour, 24 hours or 7 days. Until the platform can read them for your account, these tabs say Visible after launch: Galon shows no number before real numbers exist. CPU time per request is not measured at the time of writing.
How do I delete a function, and what is kept?
In the console, open the function, then Delete function, and type its name to confirm. The function goes offline at once: its address stops answering. Its revisions stay listed in the project, so you can roll back to one later. Through the API, POST /v1/functions/deletions with an Idempotency-Key and a body with name, revision_sha256 (the live revision) and environment creates a delete job. Deleting is allowed even when the balance is used up. The code of each revision stays in your project: open a revision and select View code to read it again or to redeploy it.
Calling the function's address returns 500 with the body Function error.
1. A 500 with Function error means your code threw an exception, or its fetch handler did not return a Response. 2. Open the function in the console, then the Logs tab, and filter by Errors: the error line of the request is there, with any console.log lines written before it. 3. Check whether the failure depends on the input: call the address again with the smallest request that fails. 4. If your code calls another host, check that the call is HTTPS on port 443 to a public host name (see Inside your function, fetch to another service fails with an error or receives 403, although the same URL works from your computer). Fix the code so that every path returns a Response, and catch errors from the calls you make, for example with try/catch around await fetch(...), returning a clear status such as 400 or 502 yourself. Deploy the fixed code as a new revision, or roll back to the last revision that worked while you fix it.
Calling the function returns 504, with the body Function timed out or a JSON error with the code functions_timeout. The next call can be slower.
1. The invocation ran longer than its maximum duration (30 seconds by default at the time of writing). 2. Look in the Logs tab at what the request was doing: an endless loop, a promise that never settles, or a slow outgoing call. 3. After a timeout, the isolated environment of your functions is restarted to free it, so the next request starts cold. Make the work shorter: set your own timeout on outgoing calls (for example with AbortSignal.timeout) and answer before the limit, move long work out of the request, and check loops for an exit. Deploy the fix as a new revision.
Deploying or rolling back returns 402 functions_balance_exhausted or functions_account_suspended; the console says Your balance is used up.
1. The project's prepaid balance is at zero: Functions refuses new deployments and rollbacks rather than creating a debt. 2. functions_account_suspended means the balance has been used up for a longer period. 3. Deleting a function still works. 4. 503 functions_balance_unavailable means the balance could not be read: a temporary error, retry. Top up the project balance in the console (Billing, Balance), then deploy again with the same request. A billing member or an admin can top up.
Inside your function, fetch() to another service fails with an error or receives 403, although the same URL works from your computer.
1. Outgoing requests are allowed only over HTTPS on port 443, to public host names. 2. Plain HTTP, an IP address instead of a host name, another port (25 included), credentials in the URL and private or internal networks are refused. 3. Check the exact URL your code builds, including the scheme and the port. Use an https:// URL with a host name on the default port. If a public host is still refused, contact support with the URL and the time (UTC).
An API call returns 403 functions_environment_mismatch, or a console rollback returns 409 functions_environment_mismatch.
1. In POST /v1/functions/deployments or /v1/functions/deletions, the environment field (test or live) must be the environment of the key used. 2. In the console, a rollback must use a key of the same environment as the revision. 3. Check the key's environment in the console, under API keys: a test key starts with gln_test_. Use a key of the environment you deploy to, or set environment to the key's environment. To deploy to live, create a live key with functions:deploy in the console. Do not reuse a test key for live.
Uploading or deploying code is refused: 415 or 422 functions_module_not_js, 413 functions_module_too_large, 422 functions_source_empty or functions_name_invalid, or the job ends in failure with an error code.
1. functions_module_not_js: the code is not a UTF-8 JavaScript module with export default outside comments, or it is WebAssembly; through the API, the Content-Type of POST /v1/functions/sources must be application/javascript or text/javascript. 2. functions_module_too_large: the module is larger than the limit (1 MiB at the time of writing). 3. functions_name_invalid: the name must be lowercase letters, digits and dashes, start with a letter, 40 characters at most. 4. 422 functions_intent_invalid: a field of the deployment body is malformed (for example compatibility_date or source_sha256). 5. A failed job carries its error code in GET /v1/functions/jobs/<job_id>. Bundle your code into one ES module with export default { fetch } and no WebAssembly, under the size limit; fix the name; send the sha256 and source_ref returned by the upload unchanged. Then deploy again with a new Idempotency-Key.
The console says Functions is being set up, a deployment returns 409 functions_not_configured, the API routes return 404 not_found, or a call returns 403 functions_tenant_not_allowed.
Functions is opened account by account. 1. Functions is being set up and 409 functions_not_configured: the platform that runs your code is not connected for your account yet. 2. 404 not_found on /v1/functions/...: the API is not open for your account. 3. 403 functions_tenant_not_allowed: this account is not on the list of accounts open to Functions. Prepare your function in the console; deploying opens when Functions is ready for your account. To ask for access, contact support.
Galon Compute
Galon Compute runs Linux virtual machines that you reach over SSH, billed per minute from your prepaid balance. It is being prepared: this help describes how it works when available in your console, covering keys, sizes and limits, billing, SSH access, deletion and the errors you are most likely to meet.
What does Galon Compute provide?
When available in your console: Linux virtual machines (images ubuntu-24.04 and debian-12, x86_64) in a single region, with SSH key logins. Disks use the standard_hdd storage class: mirrored hard disks with per-machine IOPS limits, not suited to I/O-heavy databases. At the time of writing, machines have no public IPv4 address; you connect through a Galon SSH relay, or over IPv6 when it is offered. Volumes, snapshots, backups, resizing, a web console, GPUs, Windows and nested virtualisation are not offered. GET /v1/compute/capabilities returns exactly what is served for your account.
Which API key and scopes does Compute need?
Send a Galon API key as Authorization: Bearer <key>. The scopes are compute:read (capabilities, flavors, images, SSH keys, machines), compute:quote (quotes), compute:write (add or remove SSH keys, create machines), compute:power (start, stop, reboot), compute:delete (delete a machine) and compute:usage (this month's usage). A key without the scope gets 403 scope_missing. When Compute is not open for your account, its routes answer 404 not_found. An AI assistant connected to the Galon MCP server with such a key can list sizes and images, quote, create, start, stop, reboot and delete machines through the compute tools; a deletion still needs the exact machine name.
How do I create my first machine?
1. Add an SSH public key: POST /v1/compute/ssh-keys with {"public_key": "ssh-ed25519 AAAA... you@laptop", "name": "laptop"}. 2. Choose a size with GET /v1/compute/flavors and an image with GET /v1/compute/images. 3. Get a quote: POST /v1/compute/quotes with {"flavor": "1vcpu-1gb", "image": "ubuntu-24.04"}; a quote is valid for 30 minutes. 4. Create the machine: POST /v1/compute/instances with an Idempotency-Key header (required) and a body with name, flavor, image, ssh_key_ids (1 to 5 key ids) and quote_id. The answer is 202 with the machine in state provisioning. 5. Read GET /v1/compute/instances/<id> until state is running: the ssh field gives the exact command to connect, and host_key_fingerprints lets you check the server on your first login. In the console, the Compute page does the same steps: add a key, Get a quote, then Create and start billing.
Which sizes and limits apply?
At the time of writing, and subject to change, the sizes are 1vcpu-1gb (1 vCPU, 1 GiB memory, 10 GiB disk), 2vcpu-4gb (2 vCPU, 4 GiB, 25 GiB) and 4vcpu-8gb (4 vCPU, 8 GiB, 50 GiB); GET /v1/compute/flavors also gives each size's IOPS and network limits. A project can have up to 3 machines, 8 vCPU, 16 GiB of memory, 150 GiB of disk and 10 SSH keys in total (429 compute_quota_exceeded beyond, with the limit named in detail.field). Capacity is shared: when no capacity is left for a size, creation returns 409 compute_capacity_unavailable. Outbound connections to port 25 and to some ports known to be used for mining are closed on every machine.
How is Compute billed?
Compute is prepaid from the project balance and metered per minute, in US dollars only, with prices per hour shown on the pricing page and by GET /v1/compute/flavors (the console shows hourly prices with four decimals; the monthly estimate counts the hours given by billing.monthly_estimate_hours of GET /v1/compute/capabilities, a capped month). A running machine pays for its vCPUs, memory and disk; a stopped machine pays for its disk only. Outbound traffic: each month, the first GiB given by billing.egress_included_gib_per_month (GET /v1/compute/capabilities) are included per project, the rest is billed per GiB. To create a machine, the balance must cover the hours of running given by billing.prepaid_hours_required; to start a stopped machine, the hours given by billing.prepaid_hours_required_to_start (both in GET /v1/compute/capabilities). If the balance does not cover the request, it returns 402 compute_budget_exceeded. GET /v1/compute/usage gives this month's minutes and amounts per machine.
What happens when my balance runs out?
When the project's balance is used up, Galon stops the project's running machines; it does not delete them right away. A stopped machine keeps its disk and data, and its suspension field says balance. The disk of a stopped machine is still metered. Top up the balance, then start the machine again: starting needs the hours of running given by billing.prepaid_hours_required_to_start covered by the balance. A machine stopped for lack of balance is kept the number of days given by billing.delete_after_days_without_balance (GET /v1/compute/capabilities): the account's admins receive a notice by e-mail on the day it stops, after 7 days and 7 days before the deadline; the machine's balance_stopped_at and delete_scheduled_at fields say the dates. If the balance is not topped up by then, the machine and its disk are deleted for good. Topping up at any time cancels the deletion.
How do I start, stop, reboot or delete a machine?
POST /v1/compute/instances/<id>/start, /stop or /reboot answers 202; the machine goes through starting, stopping or rebooting, then running or stopped. Only one operation runs at a time on a machine: another request meanwhile returns 409 compute_operation_conflict. To delete, send DELETE /v1/compute/instances/<id>?confirm=<exact machine name>; without the exact name the answer is 422 compute_delete_confirmation_required. Deletion removes the machine and its disk for good: there are no snapshots or backups, so copy your data off the machine first. In the console, Delete asks you to type the machine's name.
How do test and live work for Compute?
A machine is created in the environment of the key or project that creates it, test or live. When Galon runs Compute on a test cell, only test keys are accepted, and a live key gets 403 compute_test_key_only. Use a key of the right environment, created in the console.
How are machines secured, and what is my responsibility?
Machines accept SSH key logins only: password login and root login are disabled at first boot, and the default user is ubuntu or debian depending on the image. Galon accepts public keys only: a private key pasted by mistake is refused with 422 compute_ssh_key_private_refused, and RSA keys need at least 3,072 bits (ed25519 is recommended). Inside the machine, you are responsible for updates, firewall rules, your data and its backups. Galon watches for abuse signals such as sustained full CPU use or very high outbound traffic; a machine suspended after an abuse signal returns 423 compute_abuse_suspended to any action except deletion.
Creating a machine returns 402 compute_budget_exceeded, 429 compute_quota_exceeded or 409 compute_capacity_unavailable.
1. compute_budget_exceeded: read detail.reason. balance: the prepaid balance, minus what is still to be settled, does not cover the hours of this machine running given by billing.prepaid_hours_required. 2. compute_quota_exceeded: detail.field names the project limit reached (instances, vcpu, ram_gib or disk_gib). List your machines with GET /v1/compute/instances: stopped and failed machines still count. 3. compute_capacity_unavailable: no capacity is left for this size on Galon's side at the moment. For balance, top up the balance, then retry with the same Idempotency-Key. For a quota, delete a machine you no longer need, or choose a smaller size. For capacity, try a smaller size or retry later.
Creating a machine returns 409 compute_quote_expired, compute_quote_mismatch or compute_image_unavailable, or 404 compute_ssh_key_unknown.
1. compute_quote_expired: the quote is older than 30 minutes, or was made in another project. 2. compute_quote_mismatch: the quote was made for another size or image than the ones in your request. 3. compute_image_unavailable: that image is not offered at the moment; GET /v1/compute/images lists the images you can use. 4. compute_ssh_key_unknown: one of ssh_key_ids is not a key of this project (list them with GET /v1/compute/ssh-keys). Request a new quote with the same flavor and image as the creation request, use only key ids from your project, then send the creation again with a new Idempotency-Key.
The machine does not reach running: it stays in provisioning or starting, shows Failed or Being verified, or start returns 409 compute_operation_conflict or 503 compute_action_unknown.
1. Read GET /v1/compute/instances/<id>: look at state, operation and suspension. 2. provisioning or starting: the operation is still running; read again in a minute. 3. action_unknown (Being verified in the console): an operation's result is being checked; Galon checks the machine before retrying and never creates a second one. 4. failed: the operation could not be completed after several attempts. 5. compute_operation_conflict: another operation is in progress, or the machine is not in a state that allows this action (for example start on a running machine). 6. A start can also be refused with 402 compute_budget_exceeded, or 423 compute_abuse_suspended if suspension is abuse. Wait for the current operation to finish, then retry. For a failed machine, delete it and create a new one: a failed machine still counts against your quotas and its disk is still metered. For a budget refusal, top up first.
SSH says Permission denied (publickey), the connection is refused, or SSH warns that the host key does not match.
1. Use the command from the machine's ssh field exactly: through the relay it includes a port (ssh -p <port> <user>@<relay>); the user is ubuntu for ubuntu-24.04 and debian for debian-12, never root. 2. Check that the private key on your computer matches one of the keys listed in the machine's ssh_key_ids: the keys are installed when the machine is created. 3. Check that the machine's state is running: the ssh field is empty otherwise. 4. Password logins are disabled. 5. Host key warning: compare the fingerprint SSH shows with host_key_fingerprints of the machine; if they differ, do not connect. Connect with ssh -i <your private key file> and the exact command from the ssh field. If you no longer have a private key for any of the machine's keys, add a new public key to the project and create a new machine with it, after saving what you need. If the host key does not match host_key_fingerprints, stop and contact support.
Adding an SSH key returns 422 compute_ssh_key_invalid, compute_ssh_key_private_refused or compute_ssh_key_weak, or 409 compute_ssh_key_duplicate.
1. compute_ssh_key_private_refused: you pasted a private key (a block starting with -----BEGIN). Treat that key as exposed. 2. compute_ssh_key_invalid: the text is not a single public key line of a supported type (ssh-ed25519, ecdsa-sha2-nistp256/384/521, the sk- security-key types, or ssh-rsa). 3. compute_ssh_key_weak: the RSA key has fewer than 3,072 bits. 4. compute_ssh_key_duplicate: this key is already in the project. Paste the content of the .pub file, on one line. If you pasted a private key, create a new key pair (for example ssh-keygen -t ed25519) and stop using the old one. For a weak RSA key, create an ed25519 key. For a duplicate, use the existing key id from GET /v1/compute/ssh-keys.
The machine's disk is full: writes fail with No space left on device, or services inside the machine stop.
1. Inside the machine, run df -h to see which file system is full, and du -sh on large directories (logs, caches, package caches, Docker images if you use them) to find what grew. 2. The disk size is fixed by the size you chose (10, 25 or 50 GiB at the time of writing). Galon Compute does not offer extra volumes or resizing. Free space inside the machine: rotate or delete old logs, clear caches, remove what you no longer need. If the machine needs more disk, create a machine of a larger size, copy your data to it, check it, then delete the old machine.
A machine stopped by itself, or shows Suspended, and actions return 423 compute_abuse_suspended.
1. Read the machine's suspension field. 2. balance: the project's balance was used up; the machine was stopped, not deleted. 3. abuse: the machine was suspended after an abuse signal, for example sustained full CPU use or very high outbound traffic; every action except deletion returns 423 compute_abuse_suspended. 4. If suspension is empty, the machine may have been shut down from inside (for example a shutdown command). For balance, top up the balance, then start the machine. For abuse, contact support to appeal; do not create a new machine to run the same workload.
Outbound connections from the machine time out on some ports, for example sending email on port 25.
1. Galon closes outbound connections to port 25 and to some ports known to be used by mining pools, on every machine. GET /v1/compute/capabilities lists them in blocked_outbound_ports. 2. Other ports are not closed by Galon: check the firewall inside your machine and on the remote side. Send email through a provider that accepts authenticated submission on port 587 or 465 instead of port 25. Do not try to work around a closed port.
Galon Backend
Galon Backend gives your project a PostgreSQL database: one hosted by Galon, or your own database that Galon connects to. This help covers connecting, the Backend API, migrations, the schema and SQL explorer, backups and restores.
How do I start with Galon Backend?
In the console, open Services > Backend. You can create a PostgreSQL database hosted by Galon in one click, when your console offers it, or connect a PostgreSQL database you already have (Bring your own database). Each database then has the tabs Overview, Connect, Schema, SQL and Performance, plus its migrations and backups. Every action works on the project selected in the console. If Backend is not open for your account, the console does not show it; an API key gets 404 not_found or 403 backend_byo_tenant_not_allowed.
Which API key scope do I need, and can an AI assistant use Backend?
Every Backend API route takes a Galon API key with the database:create scope, sent as 'Authorization: Bearer <key>'. With it you can list and connect databases (GET and POST /v1/backend/databases), create a hosted database (POST /v1/backend/hosted/databases) and reveal its connection string, check a connection, run migrations and backups, read operations (GET /v1/backend/operations/<id>), read the schema, run read-only queries, and read or change the daily backup schedule. Writes take an Idempotency-Key header. The Galon MCP server declares five Backend tools (list_databases, create_database, get_database, apply_migrations, get_database_operation), served once Backend is open on the server; until then an AI assistant calls this HTTP API with a key. In the console, the Connect tab gives a ready prompt with the real routes of the database and no secret. Resetting a hosted database password and restoring a backup stay console gestures, done by an admin. A key without the scope gets 403 scope_missing; a missing or wrong key gets 401 api_key_missing or api_key_invalid.
How do I connect my app to a database hosted by Galon?
When you create the database, its full connection string (with the password) is shown in that response only: put it in your app's environment as DATABASE_URL. An admin can reveal it again from the Connect tab, which also gives quickstart snippets. The connection always uses TLS with certificate verification (verify-full); if the Connect tab shows a Galon certificate authority, save it as a file and point sslrootcert to it. At the time of writing a project can have up to 3 hosted databases, each with 500 MB of storage and 20 connections by default; the Connect tab shows the limits of your database. No connection pooler is provided: connect directly and reuse one small pool per app instance.
How do I connect my own PostgreSQL database?
An admin pastes the connection string once, in the form postgresql://user:password@host:5432/database. Only the sslmode parameter is accepted, and only as verify-full (or left out): Galon always verifies the server certificate. The host must be a public address: private, local and reserved addresses are refused. If your provider uses its own certificate authority, paste its CA certificates in PEM form (32 KB and 8 certificates at most), never a private key. Use Test connection first: nothing is saved by a test. Once connected, the string is encrypted and never shown again; Galon checks the connection when you connect the database and when someone runs a check. Your data stays in your database.
How do test and live work for databases?
A database belongs to one project and to one environment of that project (test or live). A key sees only the databases of its own project and environment: a database id from the other environment answers 404, as if it did not exist. Use a key of the environment where the database was created, or list the databases with GET /v1/backend/databases to get a valid id.
What does Backend cost?
At the time of writing no price is charged for Backend databases: they are not billed to the project balance, and the console shows no price. A price, once decided, will appear in the console and in these pages before it applies. Backups, when a Galon Storage bucket of your project is set, are billed as Storage, from the project balance.
How do migrations work?
Send POST /v1/backend/databases/<id>/migrations with a list of migrations, each with version, name and sql (up to 100 per request, 256 KB each and 1 MB in total). Each migration runs in its own transaction, so it must not contain BEGIN or COMMIT. A version already applied with the same content is skipped, never run twice; the same version with a different content is refused with 409 backend_migration_checksum_mismatch, and a new version older than the last applied one with 409 backend_migration_out_of_order. Galon keeps the history (versions and hashes) in the galon schema of your database. The request returns an operation: read it with GET /v1/backend/operations/<id> until it is final. An operation that waited more than an hour in the queue, or was interrupted several times, is not run and must be requested again.
What can I do in the schema and SQL explorer?
Schema lists tables, views, columns, indexes, foreign keys and extensions. The SQL editor runs one read-only statement at a time (SELECT, WITH, EXPLAIN, SHOW, TABLE or VALUES) inside a read-only transaction: it is stopped after 10 seconds, returns 100 rows by default and 500 at most, and the query itself is 64 KB at most. To change data or the schema, write a migration. An error returns its SQLSTATE and position. Galon does not keep the rows it reads. Performance shows slow queries read from the pg_stat_statements extension of your own server, when it is enabled there. The health check tests the connection step by step when someone runs it: Galon does not monitor your database continuously. With a key: POST /v1/backend/databases/<id>/diagnose, GET …/schema, POST …/query and POST …/slow-queries.
How are backups made, and how much data can I lose?
You can back up a database on demand into a Storage bucket of the project (POST /v1/backend/databases/<id>/backups with a bucket_id); a backup is 5 GB at most. When your console offers daily backups, turn them on for each database: Galon backs it up once a day at the hour you choose (03:00 UTC by default) into the bucket you choose, reads each backup back to check it, and regularly test-restores one. Retention is set by Galon (7 days by default at the time of writing) and the latest verified backup is always kept. With daily backups, changes made since the last backup, up to about one day, can be lost. Point-in-time restore is not offered. To restore, an admin uses the console: either into a new, empty database of the project, or in place, where Galon first saves a safety backup of the current state, then restores all or nothing. Both require typing the database name.
Test connection or the health check fails, or `last_check` shows status unreachable with a code such as `backend_auth_failed`, `backend_hba_rejected`, `backend_tls_certificate_invalid`, `backend_tls_hostname_mismatch`, `backend_host_unresolved`, `backend_connection_refused`, `backend_unreachable` or `backend_timeout`.
Read code, field and retryable in the check result, or run the full check (POST /v1/backend/databases/<id>/diagnose) to see which step fails: connection string, public address, network, TLS, authentication, database, migration rights. field names the part to fix: password, user, database, allowlist, ca, host, port or server. backend_auth_failed means the user or the password was refused (the server does not say which). backend_hba_rejected means the server has no rule that admits this user and database over TLS. backend_tls_* means the server certificate could not be verified, or is for another host name. backend_unreachable and backend_timeout usually mean a firewall blocks connections from the internet. backend_ipv6_unreachable means the host only answers in IPv6. Fix the named part: check the user and password (reset it at your provider if needed); add a hostssl rule for this user and database, or allow external access at your provider; paste your provider's CA certificate, or use the host name written in the certificate; allow external connections in the database firewall and check the port; for an IPv6-only host, use the address your provider gives for IPv4 connections. Then run the check again.
Connecting a database is refused with 400 or 422 and a code starting with `backend_dsn_` or `backend_ca_`, for example `backend_dsn_tls_required`, `backend_dsn_address_forbidden` or `backend_dsn_parameter_forbidden`.
The connection string or the certificate was refused before any connection. backend_dsn_scheme_invalid: it does not start with postgresql:// or postgres://. backend_dsn_credentials_missing: the user or the password is missing. backend_dsn_tls_required or backend_dsn_tls_verification_required: sslmode is disable, allow, prefer, require or verify-ca. backend_dsn_parameter_forbidden: a parameter other than sslmode follows the database name. backend_dsn_address_forbidden or backend_dsn_host_forbidden: the host is a private, local or reserved address, a socket, or a list of hosts. backend_ca_*: the CA field holds something other than PEM certificates. Copy the string again from your database provider in the form postgresql://user:password@host:5432/database, remove every parameter except sslmode=verify-full, use the public host name your provider gives for external connections, and paste only CERTIFICATE blocks in the CA field. Then connect again.
Your app cannot connect to a database hosted by Galon: certificate verification fails, the password is refused, or the server answers with too many connections.
1. Compare DATABASE_URL in your app with the string revealed in the Connect tab: user, host, port and database must match, and the user and the database have the same name. 2. If the Connect tab shows a Galon certificate authority, your client needs it (sslrootcert) to verify the certificate. 3. If the password was reset, the old one no longer opens new connections. 4. Each database accepts a limited number of connections (shown in Connect). When the connection goes through Galon's relay, the server message starts with a code such as backend_relay_tls_required (connect with TLS), backend_relay_database_mismatch (each user opens only its own database) or backend_relay_too_many_connections (retry later). Reveal the connection string again and update DATABASE_URL; keep TLS on with certificate verification and the Galon CA file if one is shown; close unused connections and reuse one small pool per app instance. For backend_relay_upstream_unavailable, retry with backoff.
Writes to a hosted database fail with a read-only error, and the Connect tab says Storage limit exceeded: this database is read-only.
The database grew beyond its storage limit (shown in Connect, with the usage and when it was measured). Galon then puts the database in read-only mode by default; reads keep working. In your own session, run SET default_transaction_read_only = off, then delete data you no longer need (and run VACUUM if useful). Writes come back once the measured size is under the limit again.
Creating a hosted database returns 409 `backend_hosted_limit_reached` or 409 `backend_database_name_taken`, or the console says the project has reached its number of hosted databases.
backend_hosted_limit_reached: the project already has the maximum number of hosted databases (3 by default at the time of writing; GET …/backend/hosted in the console shows count and max_per_project). backend_database_name_taken: a database with this name is already active in the project. Delete a hosted database you no longer use (it stops counting at once; its data is kept until the date shown on its card, export first if you need it), or create the new one in another project. For a taken name, choose another name (3 to 40 lowercase letters, digits or hyphens, starting with a letter).
A query in the SQL editor or POST …/query is stopped or refused: `backend_query_timeout`, `backend_query_not_read_only`, `backend_query_read_only`, `backend_query_multiple_statements` or `backend_query_too_large`.
backend_query_timeout: the query ran longer than 10 seconds. backend_query_not_read_only or backend_query_read_only: the query tries to write; nothing was changed. backend_query_multiple_statements: more than one statement. backend_query_too_large: the query is over 64 KB. Other codes name the cause (syntax, unknown table, column or function) with the SQLSTATE and the position. Add a WHERE clause or a LIMIT, or an index through a migration; run one statement at a time; change data or the schema with a migration, not in the editor. To find what is slow, open Performance (slow queries) after enabling pg_stat_statements on your server.
A backup or a restore fails with a code such as `backend_backup_storage_full`, `backend_backup_bucket_not_found`, `backend_backup_too_large`, `backend_backup_server_version_unsupported`, `backend_restore_confirmation_mismatch` or `backend_restore_conflict`.
Backups: the bucket is full, is not in this project, or Storage refused the upload; the database is over 5 GB; or your server runs a PostgreSQL version newer than Galon's backup tool supports. Restores: the name typed does not match the database; another operation runs on the database; for a restore in place, the safety backup could not be saved, so nothing was restored. For a restore into a new database, the target must be empty (backend_restore_target_not_empty). A backup that was not verified (backend_backup_verify_failed) is not offered as verified. Free space or raise the project's storage limit, or choose a bucket of this project; type the exact database name; wait for the running operation to finish; for a new-database restore, connect a new, empty database first. Then retry. If the latest daily backup failed its check, make a manual backup now.
Every Backend call returns 403 `tenant_suspended`, or a database returns 409 `backend_database_revoked`.
tenant_suspended: the account is suspended; nothing runs on your databases (no migration, no backup, no query). backend_database_revoked: the database was disconnected or deleted; its history stays readable, but it no longer accepts actions. For a suspended account, the owner reviews the account in the console (billing and balance). For a disconnected database you own, connect it again with its connection string; a deleted hosted database cannot be brought back, restore one of its backups into a new database.
The database password leaked or someone left the team; or, after a password reset, your app gets `password authentication failed`.
For a hosted database, Reset password in the Connect tab sets a new password. New connections with the old password are refused; connections already open stay open until they close. For your own database, the password is managed at your provider; Galon keeps only the connection string you gave it. Hosted database: an admin uses Reset password, copies the new connection string, updates DATABASE_URL in every app, then restarts them. Your own database: change the password at your provider, then disconnect the database in Galon and connect it again with the new connection string.
A migration operation ends failed, or is refused with 409 `backend_migration_checksum_mismatch`, 409 `backend_migration_out_of_order` or `backend_migration_transaction_control_forbidden`.
backend_migration_checksum_mismatch: a version already applied was sent with a different SQL. backend_migration_out_of_order: a new version is older than the last one applied. backend_migration_transaction_control_forbidden: the SQL contains BEGIN, COMMIT or another transaction command. A failed operation gives a code and a SQLSTATE (for example backend_permission_denied when the user lacks a right); the migration that failed is rolled back. backend_operation_expired: the operation waited too long and did not run. Never edit an applied migration: add a new version after the last one. Remove transaction commands from the SQL. For a permission error, grant the user the right (for example CREATE on the database). Then send the migrations again.
Galon Geo
Galon Geo turns addresses into coordinates and back, finds places around a point, computes routes and serves vector map tiles, through an API billed per request from your prepaid balance. This help covers keys and scopes, request formats, limits, billing and the errors you are most likely to meet.
What does Galon Geo provide?
Six operations under /v1/geo: GET /geocode (an address or place name to points), GET /reverse (a point to addresses), GET /places/search (places around a point, by text or by category), POST /route (a route between 2 to 25 points), GET /styles/basemap (a map style) and GET /tiles/<z>/<x>/<y>.mvt (vector tiles). Answers are GeoJSON: a FeatureCollection of Point features for geocode, reverse and places, and one LineString feature for a route. Coordinates in GeoJSON are written longitude first, then latitude. Results depend on the map data that Galon serves: check a few addresses of your own area with the console's Try it panel before you rely on them.
Which API key and scopes do I need?
Send a Galon API key as Authorization: Bearer <key>. geo:geocode covers geocode, reverse and places; geo:route covers routes; geo:maps covers the map style and tiles. A key without the right scope gets 403 scope_missing: create a key with that scope in the console and retry. Without a key you get 401 api_key_missing, and with a revoked or expired key 401 api_key_invalid. The Geo scopes can be chosen only once Galon Geo is open for your account; until then, asking for them when you create a key returns 422 scope_not_available, and the Geo routes answer 404 not_found. An app connected with OAuth can be granted the Geo scopes; each billed request then also counts against that connection's spending limit.
How do I geocode an address or search for places?
Call GET /v1/geo/geocode?q=<address or place>. Optional parameters: limit (1 to 20, 5 by default), language, lat and lon to favour results near a point, and country as a two-letter ISO code to keep only that country. GET /v1/geo/reverse needs lat and lon, with limit from 1 to 10. GET /v1/geo/places/search needs lat and lon, plus q or a category such as restaurant, pharmacy, hospital, bank, atm, fuel, school or bus_station; radius is in metres, from 100 to 50,000 (5,000 by default), and limit from 1 to 50. Text is limited to 200 characters. A parameter that is unknown, repeated or out of range returns 422 geo_query_invalid with the field named in detail.field.
How do I compute a route?
Send POST /v1/geo/route with Content-Type application/json and a body such as {"profile": "driving", "waypoints": [[-4.0197, 5.3237], [-4.0083, 5.3599]], "language": "en"}. Each waypoint is [longitude, latitude], and a route takes 2 to 25 waypoints. Profiles are driving, walking, cycling and two_wheeler (driving by default). The answer is one LineString feature whose properties give distance_m, duration_s and the steps, each with its instruction, distance and duration. When no route exists between the points for that profile, the answer is 422 geo_route_not_found. The route request takes no query parameters.
How do I show a map?
GET /v1/geo/styles/basemap with a key that carries geo:maps returns a map style document; it is not billed. The style points to the tiles at /v1/geo/tiles/<z>/<x>/<y>.mvt, zoom levels 0 to 15, and every tile request needs the same Authorization header, so configure your map client to send it. A tile that is empty answers 204 and is not counted. A billed tile answers with the headers Galon-Receipt and Galon-Amount-Micro-USD, and can be cached privately for one day. If the map is not served yet, the style and tiles answer 503 geo_maps_not_configured.
What are the rate limits and the monthly limit?
At the time of writing, each key can send up to 600 requests per minute; beyond that, requests return 429 geo_rate_limited with a Retry-After header in seconds. Each project also has a monthly Geo limit, set by Galon and counted per calendar month in UTC: when the next request would go over it, it returns 429 geo_monthly_cap_reached and nothing is served. The console's Geo page shows this month's requests and amount.
How is Galon Geo billed, and what happens when my balance runs out?
Each request is measured once, at the price of its class, and the measure is settled to the project's prepaid balance at least daily (and earlier once a small amount is due); each settlement is a line of your statement. The classes: geocoding (geocode, reverse and places), routes, or map tiles; the map style is free. Prices are shown on the pricing page and on the console's Geo page. A request that finds no result, or that is answered from cache, is still a billed request; an empty tile is not. Every answer carries a receipt (the receipt field, or the Galon-Receipt header for tiles). The balance is checked before the request is served: if it does not cover it, the answer is 402 geo_balance_exhausted and nothing is served. There is no debt. Requests from the console's Try it panel are billed like API requests. Each project also has a monthly cap, shown and adjustable on the console's Geo page, with an alert at 80 %; beyond it, requests answer 429 geo_monthly_cap_reached until the next month.
Can I try Galon Geo in the console, and how do test and live work?
In the console, open Services > Geo. The page shows whether Geo is ready, the prices, this month's usage, and a Try it panel to find a place or get a route; it is open to admins and developers of the account. Requests run in the environment of the project or key, test or live. When Galon serves Geo from a test instance, answers carry test_data: true with sample places and straight-line routes, and only test keys are accepted: a live key gets 403 geo_test_adapter_live_refused.
What does Galon keep from my requests?
Galon does not write the text you search or the coordinates you send to its logs or to its database. It records, per project and per day, the number of requests and their amount by operation, which is what the console and your receipts show. Results are kept in a memory cache for a limited time (about one day for places and tiles, one hour for routes), keyed by a fingerprint of the request without any account data. API answers are sent with Cache-Control: no-store, except tiles, which may be cached privately for one day.
GET /v1/geo/geocode answers 200 but features is an empty list, or the console's Try it panel says No place found.
1. The request was valid and served: it is billed, but nothing matched. 2. Check the country parameter: it keeps only results of that country, so a wrong code removes everything. 3. Check spelling and remove details that may not be in the map data, such as a flat number or a building name. 4. Try the district, the city or a nearby landmark, and use lat and lon to favour results near a known point. 5. Try the same text in the console's Try it panel to compare. Retry with a shorter query (street and city, or district and city), without country if you are not sure of it, and with lat and lon near the expected area. In your app, handle an empty list as a normal result and let the user pick a point on the map or use reverse geocoding.
POST /v1/geo/route returns 422 geo_route_not_found.
1. Check the order of each waypoint: it must be [longitude, latitude]. Swapped values often put a point in the sea or on another continent. 2. Check that each point is on or near a road or path usable with the chosen profile (driving, walking, cycling or two_wheeler). 3. Check that the points can be joined by land: across a sea or a closed area there may be no route. 4. Try the same points in the console's Try it panel. Fix the waypoint order, move points onto the nearest road, or change the profile, then send the route again. You can use reverse geocoding on a point to see where it falls.
A request returns 422 geo_query_invalid.
1. Read detail.field: it names the parameter that is wrong. 2. Common causes: a parameter that does not exist for this operation, a parameter sent twice, lat outside -90 to 90 or lon outside -180 to 180, limit or radius out of range, a language that is not supported, a country that is not two letters, a category that is not in the list, a waypoint that is not a pair of numbers, or a tile outside zoom 0 to 15. 3. For POST /v1/geo/route, the body must be a JSON object with only profile, waypoints and language, and no query string. Fix the named field as described in the API reference, then send the request again. Do not retry it unchanged.
Requests return 429 geo_rate_limited or 429 geo_monthly_cap_reached.
1. geo_rate_limited: this key sent more than 600 requests in the last minute; the Retry-After header gives the seconds to wait. 2. geo_monthly_cap_reached: this project reached its monthly Geo limit; it resets at the start of the next calendar month in UTC. Open Services > Geo in the console to see this month's requests and amount. 3. Look for loops that call Geo for every keystroke or every map move. For geo_rate_limited, wait the Retry-After delay and retry with exponential backoff; debounce search-as-you-type and cache results in your app. For geo_monthly_cap_reached, wait for the next month or reduce the number of requests.
Requests return 402 geo_balance_exhausted or 402 mcp_connection_spend_limit_reached.
1. geo_balance_exhausted: the project's prepaid balance, minus what is still to be settled, does not cover the price of this request. Check the balance in the console. 2. mcp_connection_spend_limit_reached: the request came from an app connected with OAuth (for example an AI assistant) that reached the spending limit a person set for it. For geo_balance_exhausted, top up the project's balance, then retry. For mcp_connection_spend_limit_reached, a person raises the app's limit in Connected apps in the console, then the app retries.
Requests return 401 api_key_missing or api_key_invalid, 403 scope_missing, or 404 not_found on every Geo route.
1. 401: the Authorization: Bearer <key> header is missing, or the key is revoked or expired. In a browser map, check that tile requests also send the header. 2. 403 scope_missing: the key lacks the scope of the operation: geo:geocode for geocode, reverse and places, geo:route for routes, geo:maps for style and tiles. 3. 404 not_found on every route: Galon Geo is not open for your account yet. 4. 403 tenant_suspended: the account is suspended. Create a key with the scopes you need in the console and use it in every request. If Geo is not open for your account, the Geo scopes are not offered when you create a key; wait until the Geo page appears in the console.
The map stays blank or shows gaps: tile requests fail or return 204.
1. Open your browser's network panel and look at the tile requests to /v1/geo/tiles/... 2. 401 or 403: the map client does not send the Authorization header, or the key lacks geo:maps. 3. 204: there is no tile at that position; nothing is billed. 4. 422 geo_query_invalid: the zoom level is above 15 or the tile numbers are out of range; set the map's maximum zoom to 15. 5. 503 geo_maps_not_configured: the map is not served yet. Configure the map client to add Authorization: Bearer <key> to style and tile requests, use a key with geo:maps, and limit the zoom to 0 to 15. A key used in a browser can be read by anyone who opens the page: create a separate key that carries only geo:maps for it.
Galon Search
Galon Search has two parts. Search indexes hold your own documents (products, articles, tickets): you send them, search them with filters, sorting, facets and highlights, and the index and its fields are created from your first batch. Site reading scrapes one page, crawls a site or maps its links and returns Markdown, HTML and links. This help covers keys, limits, robots.txt, the prepaid balance and the errors you are most likely to meet.
What can Galon Search do today?
Two things. Search indexes: POST /v1/search/indexes creates an index; sent with a documents list and no fields, it also infers the schema and writes the first batch in the same call (lot parcours-search), so two calls take you to a first result: one POST with your documents, one POST …/query. Site reading, under /v1/search/v2: POST /scrape reads one URL and returns Markdown, HTML, raw HTML or links with metadata; POST /crawl starts an asynchronous job within limits; GET /crawl/<id> returns its status and pages, 20 per response with a next link; DELETE /crawl/<id> cancels it; POST /map lists a site's URLs. The index is open to test keys of the accounts it is served to; see How do search indexes for my own documents work.
Which API key and scopes do I need?
Send a Galon API key as Authorization: Bearer <key>. Reading websites (scrape, crawl, map) needs the search:query scope. Without a key you get 401 api_key_missing; with a revoked or unknown key, 401 api_key_invalid; with a key that lacks the scope, 403 scope_missing: create a key with search:query in the console and retry. When Search is not open for your account, the routes answer 404 not_found. An app connected with OAuth can be granted search:query. For search indexes, reading and querying use search:query; writing (create or delete an index, add or delete documents, read a batch task) uses a separate scope, search:write. In the console, Galon Search shows a Create a key button that opens the key form.
How do I read a page or crawl a site?
To read one page, send POST /v1/search/v2/scrape with Content-Type application/json and a body such as {"url": "<page address>", "formats": ["markdown", "links"]}. The formats served are markdown, html, rawHtml and links; other formats return 400 format_unsupported, and an option that Galon does not serve returns 400 option_unsupported with the field named. To read a site, send POST /v1/search/v2/crawl with url, limit and maxDepth; you can add an Idempotency-Key header so that a retry does not start a second job. The answer gives the job id; read GET /v1/search/v2/crawl/<id> until status is completed, failed or cancelled, and follow next to get the remaining pages. Pages are read as served: JavaScript is not run, so waitFor and actions return 400 javascript_rendering_unavailable.
What are the limits on crawls, pages and requests?
At the time of writing, and subject to change: a crawl job reads at most 100 pages (a higher limit is lowered to 100 and the answer carries the warning limit_capped), to a depth of at most 5 (2 by default), for at most 15 minutes; a project runs at most 2 crawl jobs at once (429 crawl_limit_reached). A page can be up to 5 MB, a map returns up to 1,000 links, and a page waits at most 60 seconds. Galon sends at most one request per second to the same site. Default quotas are 1,000 pages per project per month, 5,000 pages per account per month across all projects, and 1,000 requests per project per day; beyond them you get 429 quota_exceeded, tenant_quota_exceeded or daily_limit_reached, with the reset time in detail.resets_at.
How does Galon Search treat the sites it reads?
Galon reads sites as GalonBot and checks robots.txt before reading a page. If robots.txt forbids the page, the request returns 403 robots_disallowed. If robots.txt answers with a server error or cannot be reached, Galon does not read the site and returns 403 robots_unreachable; if the site has no robots.txt (a 4xx answer), pages are allowed. A Crawl-delay for GalonBot is respected. Galon never reads private, local or reserved network addresses (403 url_blocked), and a site reachable only over IPv6 is refused with 403 ipv6_unsupported. Only HTML, plain text and Markdown pages are read; other content types return 415 content_type_unsupported. Read only the sites you are allowed to read.
How is Galon Search paid, and what happens when my balance runs out?
Galon Search is prepaid, in USD only, and billed by the unit the market uses. Search indexes: a price per 1,000 queries and a price per 1,000 documents stored per month (the highest count of each day, prorated per day); writing documents is included. Reading websites: a price per page read (scrape, crawl) and per map call; a page that fails is not counted. The prices and their market reference are shown on the pricing page and in the project's pricing status; while a project is in the pilot, the status is pilot and nothing is taken from the balance. Each request is checked against the project's balance BEFORE the service: the balance, minus what is already due, must cover it, otherwise it returns 402 (insufficient_balance for site reading, search_balance_exhausted for indexes) and nothing is read or written. There is no debt. Usage is measured to the micro-dollar and shown on a receipt; whole cents due are taken from the balance every 15 minutes, never a cent rounded up per request. Search indexes are open to test keys only while their prices are not set (403 search_live_not_open on a live key).
How do search indexes for my own documents work?
The short way: send POST /v1/search/indexes with a body {"name": "products", "documents": [...]} and no fields. Galon infers the fields from your documents: titles weigh more, short values without spaces become keywords (filters, sorting, facets), numbers and dates can be filtered and sorted, lists of strings become keywords, longer strings are searchable text. The index is created and the batch written in the same call, all or nothing: one invalid document and nothing is created. The console does the same in one Import button. The explicit way: send name, language (en, fr or simple) and 1 to 50 fields, each with a type (text, keyword, keywords, number, boolean or date) and the flags searchable, filterable, sortable and facetable, then POST /v1/search/indexes/<name>/documents with {"documents": [...]}: at most 1,000 documents per request, 64 KB per document, each with an id. Send an Idempotency-Key header so that a retry does not write twice. A document that has not changed is not written again. At the time of writing, the default limits are 10 indexes per project and 100,000 documents per index.
How do I query an index?
Send POST /v1/search/indexes/<name>/query with a body that can carry q (up to 512 characters), filter, sort (up to 3 keys, on sortable fields or _score), facets (up to 10 facetable fields), limit (1 to 100, 20 by default), offset (up to 1,000), highlight and typo_tolerance. The answer lists hits with their score and document, the total, the facets and took_ms. Text in double quotes is matched as a phrase, without typo tolerance. A query that takes too long is stopped: narrow it with a filter or fewer facets. In the console, Try a search runs the same request, and Copy this request gives you the exact call in curl, JavaScript or Python with your index name.
What data does Galon keep, and how do I delete it?
Scrape and map requests keep no page content. The pages read by a crawl job can be read for 24 hours after the job ends, at the time of writing, then they are deleted: after that, GET /v1/search/v2/crawl/<id> returns 404 crawl_expired. Usage counters and receipts, without page content, are kept longer. Logs carry only the site's host, numbers and an error code, never the full URL or the page. To stop a running job, send DELETE /v1/search/v2/crawl/<id>. For search indexes: DELETE /v1/search/indexes/<name> deletes the index and all its documents (the console has a Delete this index button, confirmed before anything happens), and POST /v1/search/indexes/<name>/documents/delete deletes documents by id. Your documents are yours: they are deleted with your account, and your data export includes them.
A scrape or crawl returns 403 with the code robots_disallowed or robots_unreachable.
1. Open /robots.txt at the root of the site in a browser. 2. robots_disallowed: a rule for GalonBot or for all agents forbids the path you asked for. 3. robots_unreachable: robots.txt answered with a server error (5xx) or could not be reached at all; in that case Galon reads nothing on the site, by design. 4. If the site has no robots.txt and answers 404, pages are allowed: robots_unreachable then points to a server or network problem on the site's side. Read only pages that robots.txt allows: change the URL, or use includePaths and excludePaths to keep a crawl within allowed paths. If you run the site, allow GalonBot in robots.txt or fix the server error on robots.txt, then retry. The error is not about your key or project: no change in the console fixes it.
The request returns 400 url_invalid, or 403 url_blocked or ipv6_unsupported.
1. url_invalid: the URL must be an absolute http or https URL on a standard port, without a user name or password, and at most 2,048 characters. 2. url_blocked: the host is, or resolves to, a private, local or reserved address (for example localhost, an internal name or a private IP); Galon never reads those. 3. ipv6_unsupported: the site has no IPv4 address. Use the public address of the site, with the https or http scheme, without credentials. To read a site on your own network, publish it on a public address first. For an IPv6-only site, add an IPv4 address to it if you run it.
Requests return 429 with quota_exceeded, tenant_quota_exceeded, daily_limit_reached, crawl_limit_reached or rate_limited.
1. Read the code and detail.resets_at in the error body. 2. quota_exceeded: the project's monthly pages are used; tenant_quota_exceeded: the monthly pages of your whole account are used; both reset at the start of the next month (UTC). 3. daily_limit_reached: the project's daily requests are used; it resets at midnight UTC and the Retry-After header gives the seconds left. 4. crawl_limit_reached: two crawl jobs are already running in the project. 5. rate_limited: Galon is waiting between requests to the same site (one per second, or the site's Crawl-delay). For rate_limited, wait the Retry-After delay and retry with backoff. For crawl_limit_reached, wait for a running job to finish, or cancel one with DELETE /v1/search/v2/crawl/<id>. For the monthly and daily quotas, wait for the reset time, or lower the limit of your crawls so that they use fewer pages.
A crawl job ends with status failed, or GET /v1/search/v2/crawl/<id> returns 404 crawl_expired or crawl_not_found.
1. Read the code field of the job. 2. crawl_interrupted: the job stopped reporting progress for 2 minutes. 3. crawl_time_limit: the job reached its 15-minute limit; it is completed and the pages read are kept. 4. A failed job with no page read carries the first page error, for example site_unreachable, tls_invalid or scrape_timeout: open the start URL in a browser to check that the site answers over HTTPS with a valid certificate. 5. crawl_expired: the results were deleted 24 hours after the job ended. 6. crawl_not_found: the id is not a job of this key's project. Start a new job for the same site; for crawl_time_limit, lower limit or maxDepth, or split the site with includePaths. For crawl_expired, start the job again and read its pages within 24 hours. For crawl_not_found, use a key of the project that created the job.
A page comes back empty or incomplete, or returns 400 javascript_rendering_unavailable, 415 content_type_unsupported or 422 page_too_large.
1. Galon reads the page as the server sends it and does not run JavaScript: a page that builds its content in the browser can come back almost empty. Check the page with JavaScript disabled in your browser. 2. javascript_rendering_unavailable: the request carries waitFor or actions. 3. content_type_unsupported: the URL is not HTML, plain text or Markdown (a PDF or an image, for example). 4. page_too_large: the page is over 5 MB. 5. too_many_redirects: the URL redirects more than 5 times. 6. onlyMainContent is on by default: set it to false if the part you need is outside the main content. Remove waitFor and actions. Point to a URL that serves the content as HTML, for example a server-rendered or static version of the page. For large pages, read a more specific URL.
When search indexes are available: a call returns 404 search_index_not_found or search_document_not_found.
1. List the indexes of the key's project with GET /v1/search/indexes. 2. Index names are lowercase: My-Index and my-index are not the same, and a name with capital letters is never found. 3. Indexes belong to one project: a key of another project does not see them. 4. A deleted index and its documents cannot be read again. Use the exact name returned by the list, with a key of the same project. If the index was deleted, create it again and send its documents again.
When search indexes are available: adding documents returns 422 search_document_invalid, or 413 search_document_too_large, search_batch_too_large or body_too_large.
1. Nothing from the batch was indexed: a batch is all or nothing. 2. Read detail.errors: up to 20 entries, each with the position in the batch, the document id, the field and the reason (for example unknown_field, id_invalid, duplicate_id, too_large, or secret_detected when a value looks like a private key or a Galon API key). 3. A field that is not in the index schema is refused. 4. Limits: 1,000 documents per request, 64 KB per document, 5 MB per request body. Fix or remove the documents named in detail.errors, keep only the fields of the schema, and split large batches. Never put keys or secrets in documents. Send the batch again: with the same Idempotency-Key only if the batch is unchanged, with a new key otherwise.
When search indexes are available: a query returns 200 with no hits, although the documents were sent.
1. Read the task returned when you sent the documents (GET /v1/search/tasks/<task_id>): indexed, unchanged, stale and not_found tell you what was written; stale documents had a lower _version than the stored one and were ignored. 2. Read the index (GET /v1/search/indexes/<name>) and check that the fields you search are searchable: only those are matched by q. 3. Check the index language (en, fr or simple) against the language of your documents. 4. Remove filter and quotes from the query: a filter can exclude every document, and text in double quotes is matched as an exact phrase without typo tolerance. 5. Check that the key belongs to the project of the index. Recreate the index with the right searchable fields or language if needed and send the documents again; otherwise widen the query, then add the filter back one condition at a time.
Galon Deploy
Galon Deploy builds a commit of your repository, or a static site you upload, into a private preview, then serves a verified preview in production on your own domains. This help covers previews, builds, production plans, custom domains, rollback and the errors you are most likely to meet.
How do I deploy my first site?
In the console, open Deployment in a test project. Choose Import from GitHub, connect your own GitHub account, pick the repository and its branch, then select Deploy: Galon reads the source at one exact commit, detects the framework, builds it in an isolated machine, scans the output and publishes a private preview. Each push to the linked branch then adds a preview. You can also deploy one commit by its reference (advanced option). Through the API, create a deploy with POST /v1/deploy/journeys (with an Idempotency-Key), then call POST /v1/deploy/journeys/<id>/resume until its status is ready or failed. An AI assistant connected to the Galon MCP server does the same with the tools start_deploy, advance_deploy and get_deploy. When available for your account, a static site without a repository can be uploaded as files or a ZIP or tar archive (tool deploy_archive, POST /v1/deploy/archives) with index.html at its root.
Which API key and scopes does Deploy need?
Previews are created with a key of a test project. Starting and advancing a deploy needs the deploy:create scope; reading a deploy needs job:read. A live key gets 404 not_found on the preview routes. Production changes (plan, domains, promotion, rollback) need a live key with deploy:create; a test key gets 403 deploy_production_live_key_required. A missing scope returns 403 scope_missing: create a key with that scope in the console and retry. In the console, the admin and developer roles can deploy; choosing a paid plan needs a billing member or an admin. An assistant connected by OAuth can start previews, but choosing a plan or promoting to production is an approval request that a person confirms in the console.
What is the difference between a preview and production, and between test and live projects?
A preview is built and served in a test project. It is private by default and it has an expiry: when you set it through the API, it can be at most 7 days after its creation. Production lives in the live project with the same name as your test project, and is paid from that live project's balance. To go to production, the live project needs an active Deploy plan and at least one verified domain; you then promote a ready preview from the test project. Only a preview whose build, security scan and publication all succeeded can be promoted. Promotion switches the production pointer and keeps the previous release, so you can roll back.
What can Galon build, and with which limits?
Galon serves static sites and static exports, for example Vite, React, Vue, Svelte, Astro, Nuxt generate and Next.js with output: 'export'. It detects the framework, the package manager (npm, pnpm or yarn) and proposes install and build commands and an output directory; you can override each one under Build and output settings. A project that needs a server (server rendering, API routes, a Node.js or Python server) is refused at the plan step with framework_server_runtime_not_served, unless server rendering is available for your account. Each build runs alone, at the time of writing with 2 vCPU, 3 GB of memory, 600 seconds to install, 900 seconds to build and 1,200 seconds in total. Packages are installed from Galon's package mirror; the build command has no network access. Where building repositories is not switched on yet, a plain static site with an index.html at its root still deploys.
What are the limits of free previews?
When daily limits apply to your account, they are, at the time of writing: 10 preview deployments per account per UTC day, one build at a time per account, and a small number of builds at once on the whole platform; extra builds wait in a first-come, first-served queue and are never refused for that reason. A retry with the same Idempotency-Key and the same request is not counted twice. Over the daily limit, creating a deploy returns 429 deploy_quota_daily_exceeded with a Retry-After header (seconds until 00:00 UTC) and the fields limit, used and resets_at. Production deployments on a paid plan do not count towards the daily limit. The Deployment page shows your counter and your position in the queue. A repository source is limited to 512 files, 2 MiB per file and 10 MiB in total; an uploaded archive to 25 MiB.
What does Deploy cost, and how is it paid?
Previews are free. Production needs a Deploy plan, paid in advance from the prepaid balance of the live project, for 30 days at a time; there is no debt and no overdraft. Prices and what each plan includes are on the pricing page. Galon sends alerts when builds or traffic reach 75 % and 90 % of what the plan includes; reaching them does not stop the site. If the balance does not cover the plan, the request returns 402 deploy_plan_balance_insufficient: top up the balance, then choose the plan again. If a spending limit set for the project would be exceeded, the request returns 402 deploy_plan_spend_limit_reached: raise the limit in Billing or choose a smaller plan.
How do environment variables work in a build?
Variables are set per project and per environment (test or live), each one public or secret, in the project settings of the console. Only public variables are available during the build. A site is public by nature: anything the build writes into its files, such as variables starting with NEXT_PUBLIC_ or VITE_, can be read by every visitor, so never put a key or a password in a public variable. Names use capital letters, digits and underscores; names starting with GALON_ and names reserved by the build environment (for example PATH or NODE_OPTIONS) are refused. At the time of writing a project holds up to 100 variables per environment, 4 KiB per public value. Build logs mask the values of the project's variables. With a key that has deploy:create, GET /v1/deploy/env lists the variable names and the values of public variables only, when that route is available for your account.
Who can open a preview, and how do I remove things?
Previews are private by default: project members open them with Visit. Under Deployment protection you can set a password (8 to 128 characters) for visitors without an account, create share links that expire or last until you revoke them, or make previews public. A new preview password is shown once; replacing it stops the old one at once. A preview stops being served at its expiry. To stop serving a custom domain, remove it under Production > Domains: your deployments are kept. To stop previews on push, unlink the repository. Production is never erased when a plan lapses: it is suspended, not deleted.
What does Galon read from my repository, and what does it keep?
Galon reads only the repositories you choose when you connect your GitHub account, at one exact commit. The build runs in an isolated machine with no access to Galon's secrets. Before anything is published, the source and the output are scanned: a private key or a known secret format found in the code or in the output blocks the deploy (source_secret_detected, build_output_secret_detected), and nothing is published. Build logs are cleaned, size-limited and mask your variables' values. Pull requests opened from forks are not built, so the project's variables stay private. Deployments list the commit, its branch and its message, never its author.
The deployment stops at the Build step with status Failed. The deploy's error names a code such as build_install_failed, build_command_failed, build_timeout or build_memory_exceeded, or the Plan step refuses with build_script_missing, package_manager_unsupported or framework_server_runtime_not_served.
1. Open the deployment and read Install and build logs; select Go to the error to see the highlighted line. 2. build_install_failed: the install command failed, usually a lockfile out of date or a dependency that cannot be resolved from the package mirror. 3. build_command_failed: your build script exited with an error; the highlighted line says why. 4. build_timeout: the build went past its time limit (at the time of writing 600 seconds to install, 900 to build, 1,200 in total). 5. build_memory_exceeded: the build used more than its memory (3 GB at the time of writing). 6. Plan refusals mean Galon could not find how to build: no build script in package.json, a package manager other than npm, pnpm or yarn, or a framework that needs a server. Run the same install and build commands locally from a clean checkout, fix the error, commit and push (or redeploy the new commit). Commit your lockfile. Remember that the build command has no network access: download nothing at build time. For time or memory, remove unused dependencies or heavy build steps. For a server framework, configure a static export (for Next.js, output: 'export') if your site can be static. If a setting was overridden under Build and output settings, check it, or reset it to the detected value.
The preview address answers 404 Not found, shows the wrong page, or an app route such as /dashboard returns 404 after a reload. Or the preview answers 409 deploy_preview_not_ready, or 410 deploy_preview_expired or deploy_preview_removed.
1. Check the deployment status: a preview can only be opened once it is Ready (409 deploy_preview_not_ready before that). 2. Check its expiry: after it, the preview returns 410. 3. Read Build output: the output directory and the number of files published. If the build failed with build_output_missing or build_output_index_missing, the output directory was wrong or has no index.html at its root. 4. A missing file (for example /logo.png) returns 404 as it should. 5. Where routing rules are available for your account, your own 404.html is served for unknown paths, and for a single-page app a navigation path that is not a file returns index.html when the single-page app fallback applies (detected for Vite, React Router, Create React App and Vue CLI, or forced in settings). Set the Output directory under Build and output settings to the folder your build writes (for example dist or out), then deploy again. Make sure index.html is at the root of that folder. For a single-page app, set Single-page app fallback to Always serve index.html; it applies to the next deployment. If you use _redirects or _headers files and a rule is refused, the log names the file and the line: fix it, then deploy again. For an expired or removed preview, deploy the commit again: a new preview gets its own address.
A custom domain stays at DNS update needed, Verify DNS answers that the records are not visible yet (deploy_domain_txt_missing or deploy_domain_routing_missing), or the domain is verified but the browser shows a certificate or connection error.
1. In the live project, open Production > Domains and compare each record shown with what your DNS provider publishes. Ownership is a TXT record named _galon-challenge.<your domain> whose value starts with galon-site-verification=. Routing is either a CNAME (for a subdomain such as www) or A records (for the apex) pointing to the targets shown; an A record set next to a CNAME, or an extra address, fails the routing check. 2. Use a DNS lookup tool to see what the public DNS returns; DNS changes can take a few minutes, sometimes longer. 3. Verifying a domain needs an active Deploy plan: without one, Verify returns 402 deploy_plan_required. 4. 409 deploy_domain_claimed_elsewhere means another account uses this domain. 5. HTTPS is issued on the first visit, only once the domain is verified and the project has production running (a plan active or in grace, and a promoted release). Create or correct the TXT and the CNAME or A records exactly as shown, remove conflicting records for the same name, wait a few minutes, then select Verify DNS again. Choose a plan first if verification asks for one. Once verified, promote a ready preview, then open the domain over HTTPS. For a domain claimed by another account, prove you control it with the TXT record, then try again.
Creating a deploy returns 429 deploy_quota_daily_exceeded with a Retry-After header, or adding a domain returns 403 deploy_domain_pending_limit_reached, or verifying one more domain returns 409 deploy_plan_domain_limit_reached.
1. deploy_quota_daily_exceeded: you used the free previews of the UTC day; the body gives limit, used and resets_at, and Retry-After the seconds until 00:00 UTC. The Deployment page shows the same counter. 2. deploy_domain_pending_limit_reached: without a Deploy plan, an account can have only a few domains waiting for verification (3 by default at the time of writing); the body gives limit and used. 3. deploy_plan_domain_limit_reached: your plan already has as many verified domains as it includes. 4. deploy_plan_downgrade_exceeds_domains: the smaller plan you chose includes fewer domains than you have verified. For the daily limit, wait until the time in resets_at, then retry with the same Idempotency-Key; a production deploy on a paid plan does not count. For pending domains, verify or remove a pending domain, or choose a Deploy plan. For the plan's domain limit, remove a domain or choose a larger plan on the pricing page. An assistant must not loop on 429: it waits for Retry-After.
The Production page shows Renewal not paid, or Production suspended, and the site on your domain is no longer served. Or promoting returns 402 deploy_plan_required.
1. A plan runs for 30 days paid in advance. If the renewal is not covered by the live project's prepaid balance, production enters a grace period of 14 days: the site stays online but new releases are paused (promotion returns deploy_plan_required; rollback still works). 2. After the 14 days, production is suspended: the site is no longer served. Nothing is erased. 3. Admins and billing members receive notices by email when the grace period starts and seven days before suspension, where notices are enabled. 4. Check the balance of the live project in Billing. Top up the balance of the live project. During grace, a top-up renews the plan; once suspended, choose a plan again to serve the site. If the payment of the plan is refused with deploy_plan_spend_limit_reached, raise the project's spending limit in Billing or choose a smaller plan.
Rolling back production returns 409 deploy_production_no_previous, 402 deploy_plan_required, or 404 deploy_production_release_not_found.
1. Roll back to the previous release swaps the current release with the previous one; nothing is rebuilt. It needs a previous release: after the first promotion there is none (deploy_production_no_previous). 2. Rollback works while the plan is active or in grace; once production is suspended it returns deploy_plan_required. 3. Rolling back to an older chosen release (POST /v1/deploy/production/rollback with a release_id), when available for your account, returns 404 deploy_production_release_not_found if that release does not belong to this project. 4. 409 deploy_production_conflict: another change to production happened at the same time. In the live project, open Production and select Roll back to the previous release, or call POST /v1/deploy/production/rollback with a live key that has deploy:create. If there is no previous release, promote the earlier ready preview you want instead. After a conflict, refresh the production status, then try again once.
A preview route answers 404 not_found with a valid key, a production change answers 403 deploy_production_live_key_required or 409 deploy_production_live_project_required, or the console answers 409 deploy_preview_project_live.
Each key belongs to one project and one environment. 1. Previews accept only a key of a test project: a live key sees nothing (404 not_found). 2. Production changes accept only a live key (403 deploy_production_live_key_required with a test key). 3. In the console, previews are built in the test project (409 deploy_preview_project_live in a live project) and production is managed in the live project with the same name (409 deploy_production_live_project_required in a test project). 4. 403 scope_missing: the key lacks deploy:create or job:read. Use a test key with deploy:create and job:read to create and follow previews, and a live key with deploy:create for plan, domains, promotion and rollback. Create the missing key in the console (API keys, New key). In the console, switch to the test project to deploy and to the live project to promote; create the live project with the same name if it does not exist.
Connecting GitHub or deploying from it fails: the installation waits for approval (source_installation_pending_approval), the repository is not accessible (source_repository_not_accessible), the linked branch no longer exists (source_branch_not_found, deploy_source_branch_not_found), or the console says Importing from GitHub is not open to this account yet.
1. Pending approval: in a GitHub organisation, an owner must approve the Galon app installation. 2. Not accessible: the installation does not include this repository, or its access was removed. 3. Branch not found: the branch linked to the project was renamed or deleted. 4. Suspended: the installation was suspended on GitHub. 5. Pull request previews need the permissions GitHub asks you to accept for the Galon app. 6. 403 deploy_tenant_not_allowed: Deploy is not open to this account yet. Ask an owner of the GitHub organisation to approve the installation, or select Adjust GitHub access to add the repository, then refresh the console. Link another branch, or deploy a specific commit by its reference. Accept the new permissions for the Galon app on GitHub, then select Retry on the pull request.
Galon AI
How to call Galon AI, the model gateway paid per use from your project balance: keys and scopes, models, limits, billing, idempotency and the errors you are most likely to see. Galon AI is open to every account; features marked 'when available' depend on your account.
How do I make my first Galon AI request?
Galon AI is open to every account: 1) in the console, top up the project balance (requests are reserved on it before the model runs), then create an API key with the ai:inference scope; 2) call GET /v1/ai/models on your Galon API base URL with the header 'Authorization: Bearer <key>' and pick a model id; 3) call POST /v1/ai/chat/completions with 'Content-Type: application/json' and a body with model and messages. The reply follows the chat completions format (id, choices, usage) and carries X-Request-Id and the amount charged in its headers. Any OpenAI-compatible (Chat Completions) client works as is if you point its base URL to your Galon API base followed by /ai. For safe retries, send your own unique 'Idempotency-Key' header and reuse it; without it the server sets one and returns it in the response headers.
Which key and scope do I need, and how do test and live work?
Every call needs an API key sent as 'Authorization: Bearer <key>' that carries the ai:inference scope; without the scope you get 403 scope_missing. A missing header returns 401 api_key_missing, an unknown, revoked or expired key 401 api_key_invalid, and a suspended account 403 tenant_suspended. A key belongs to one project and one environment: test keys start with gln_test_, live keys with gln_live_. Quotas, usage and Idempotency-Keys are counted per project and environment, and each request is paid from the balance of the key's project, test or live alike. The secret of a key is shown once, when you create it: store it on your server, never in a browser or a mobile app.
Which models can I use, and what happens when a model is retired?
GET /v1/ai/models lists the models served to your project, under their real names, with publisher, category, licence, context length and price. Use the returned id as model; an id that is not in the list returns 404 ai_model_not_found. When a model reaches its end of life and its catalogue entry declares a replacement that Galon serves, your request is served by the replacement and the response carries the header X-Galon-Model-Replaced-From with the name you sent. Without a served replacement you get 410 ai_model_retired with its end_of_life date: choose another model from GET /v1/ai/models. Some models are subject to their publisher's licence, shown with the model; you must comply with it.
Which request fields does Galon AI accept?
By default the body accepts model, messages, max_tokens or max_completion_tokens (not both), temperature, top_p, stop, stream, n (1 only), seed, presence_penalty and frequency_penalty. Each message has a role (system, user or assistant) and a text content, as a string or as text parts; up to 256 messages. Any other field is refused with 400 ai_field_not_supported and its name in 'field': it is never ignored silently. stream: true is accepted only for a model served with streaming; otherwise you get 400 ai_streaming_not_supported. Tools, tool_choice, response_format and image input are accepted, when available for your account, only for a model whose catalogue entry lists the capability; otherwise you get 400 ai_model_capability_unsupported.
How am I charged, and how do I follow my spending?
Galon AI is prepaid. Before calling the model, Galon reserves an upper estimate on your project balance, based on the size of your input and on max_tokens at the model's price. The request is then settled at the usage the model actually reports, never above the reservation, and the rest is released. A request that fails before any reply is settled at zero. The response header shows what the request cost: X-Galon-Charge-USD-Minor means the request was rounded up to the next whole cent; X-Galon-Charge-USD-Micro means it was billed in micro-USD at the tokens reported, and only whole cents of your project's running total are taken from the balance (the remainder below one cent is carried over). A reply cut by max_tokens before any output (finish_reason length, empty content) is billed like any reply, at the tokens the model reports in usage: it carries a notice (code ai_output_empty_max_tokens) and the header X-Galon-Notice. Prices per model are in GET /v1/ai/models and on the pricing page. In the console, the Usage tab of Galon AI shows requests, tokens and cost per day and per model.
What are the limits and quotas of Galon AI?
At the time of writing, the default quotas are 10,000 requests a day and 100,000 a month per project and environment, counted in UTC days and months. The text of the messages is limited to 65,536 bytes (64 KiB) per request, with at most 256 messages, and the HTTP body to 2 MiB (8 MiB when image input is available for your account). The maximum output of each model is in its catalogue entry. A reached quota returns 429 ai_quota_exhausted with a Retry-After header giving the seconds until it resets. Galon also sets spending ceilings per request, per day and per month for each project (see 402 ai_budget_exhausted or ai_request_exceeds_limit while your balance is positive). The Overview tab of Galon AI in the console shows your quotas, their use and when they reset. These limits protect the platform; to raise them, contact support.
Is the Idempotency-Key header required, and how do retries behave?
The Idempotency-Key header is optional on POST /v1/ai/chat/completions and /v1/ai/embeddings. Send your own key (8 to 200 visible ASCII characters, without spaces) when you want safe retries; without it, the server sets one and returns it in the Idempotency-Key response header. A malformed key answers 400 idempotency_key_invalid. A request is recorded once per key and per project, so you never pay twice for it. Sending the same key again does not call the model again and does not return the first reply: you get 409 ai_request_in_progress while the first request runs, 409 ai_request_already_processed once it is finished (with its request_id and a status succeeded or failed), or 409 idempotency_conflict if the body differs. Rule of thumb: use a new key for each new attempt. After 402 ai_wallet_insufficient_funds or 429 ai_quota_exhausted nothing was recorded and the same key can be reused once the cause is fixed; after a failure from the model (5xx) or an interrupted stream, the attempt is recorded, so send the retry with a new key.
Can my AI coding assistant use Galon AI?
Yes, through the Galon MCP server. The tools list_ai_models and create_chat_completion call the same API with the ai:inference scope and are paid from the project balance; create_chat_completion takes an idempotency_key argument, which must be new for each new request. An assistant connected with an API key acts within that key's scopes. An app connected with OAuth, without a key, is also bound by the spending limit a person sets for it in Connected apps in the console; only a person can raise that limit. Topping up the balance is always done by a person in the console.
What happens to my prompts and outputs?
Your prompts and outputs are processed by the inference provider that serves the model you choose; each provider is named on the Subprocessors list. Galon's own record of a request keeps the model, the output limit and a fingerprint of the request, not your prompt or the reply: the Logs tab of Galon AI shows these metadata only. When the API request log is available for your account and turned on, it keeps the first 8 KB of request and response bodies for 30 days, with secrets, e-mail addresses and phone numbers masked. Responses never name the hosting provider. Outputs may be inaccurate or incomplete: review them before use.
A chat completion returns 402 with code ai_wallet_insufficient_funds.
The available balance of the key's project does not cover the reservation of this request, or the project has no balance yet. Amounts reserved by requests still running count as used. 1) Check the balance in the console (Usage & billing, Balance tab). 2) Check that the key belongs to the project you topped up: test and live projects have separate balances. 3) Look at max_tokens: the reservation grows with it and with the size of your input. Top up the balance in USD in the console, then retry with the same Idempotency-Key: nothing was recorded. Or lower max_tokens; if you change the request, send it with a new Idempotency-Key.
Requests return 429 with code ai_quota_exhausted or ai_upstream_rate_limited and a Retry-After header.
Read the code. ai_quota_exhausted: your project reached its daily or monthly request quota (UTC day and month); Retry-After gives the seconds until it resets, and the Overview tab of Galon AI shows the quotas and their use. ai_upstream_rate_limited: the model is receiving too many requests at the provider; nothing was charged. Many parallel calls reach rate limits sooner. Wait at least the Retry-After delay, then retry with exponential backoff. After ai_quota_exhausted the request was not recorded and the same Idempotency-Key can be reused. After ai_upstream_rate_limited the attempt was recorded as failed: send the retry with a new Idempotency-Key. To raise a quota, contact support.
The model is refused: 404 ai_model_not_found, 410 ai_model_retired or 400 ai_model_wrong_endpoint.
Call GET /v1/ai/models with the same key and compare the ids with your model value, character for character. 404: this id is not served to this project (typo, model of another catalogue, or Galon AI not enabled for this account). 410: the model reached its end of life without a served replacement; the error carries end_of_life when Galon knows it. 400 ai_model_wrong_endpoint: an embeddings model was sent to /chat/completions, or a chat model to /embeddings. Pick an id from GET /v1/ai/models (or from the MCP tool list_ai_models), then send the request again with a new Idempotency-Key. Do not retry the same body unchanged.
The request is too long: 400 ai_context_length_exceeded, 413 ai_input_too_large or 413 body_too_large.
ai_context_length_exceeded: the messages plus max_tokens exceed the model's context window (its context length is in GET /v1/ai/models); 'field' says whether messages or max_tokens is at fault. ai_input_too_large: the text of the messages is over the input limit per request (65,536 bytes at the time of writing) or larger than the model accepts. body_too_large: the HTTP body is over 2 MiB (8 MiB with image input, when it is available for your account). Shorten or summarise earlier messages, send only the context you need, or lower max_tokens; then send the new request with a new Idempotency-Key.
With stream: true, the stream ends with an event whose error.code is ai_stream_interrupted, without the final 'data: [DONE]' line, or your client lost the connection mid-stream.
The connection to the model broke after the reply had started. Galon never replays a stream once its first event is sent. Only the tokens actually received were charged; if nothing was received, nothing was charged. A client that disconnects is also charged only for the usage received. Keep or discard the partial text, then send the request again with a new Idempotency-Key: the first one is recorded. For long replies, consider a request without streaming or a lower max_tokens.
The reply is filtered: 400 ai_content_filtered, a 200 reply whose finish_reason is content_filter, or 502 ai_response_unsafe.
ai_content_filtered: the model's content policy rejected your input; nothing was charged. finish_reason content_filter: the model stopped its own output; the reply is billed at the usage reported, like any completed reply. ai_response_unsafe: Galon withheld a reply that failed its output check before it reached you; it is not billed as a success, and the amount reserved may stay held until Galon reconciles the request. For ai_content_filtered or content_filter, rephrase or split the input, then send it with a new Idempotency-Key. For ai_response_unsafe, retry once with a new Idempotency-Key. The AI rules of the Acceptable Use Policy apply to every request.
429 ai_rate_limited, with a Retry-After header and RateLimit headers.
This key sent more requests, or more tokens (input bound plus the maximum output requested), than its one-minute sliding window allows. The error detail says the limit applied (limit), the usage that reached it (used), the unit (request or token), the window in seconds and the policy; every successful response carries RateLimit-Policy and RateLimit headers so a client can pace itself before being refused. Nothing was reserved or charged. Wait the seconds given in Retry-After and send the same request again (same Idempotency-Key if you set one), spread the load over several keys (each key has its own window), or lower max_tokens when the token window is the one reached. The limits apply per key; the console overview and the Limits page show the values in force.
409 ai_request_already_processed, ai_request_in_progress, ai_request_pending_review, ai_request_cancelled or idempotency_conflict, or 400 idempotency_key_invalid.
All come from the Idempotency-Key header. 400 idempotency_key_invalid: the header is present but not 8 to 200 visible ASCII characters (a missing header is fine: the server sets one). ai_request_in_progress: a request with the same key is still running. ai_request_already_processed: the key was used by a finished request; 'status' says succeeded or failed and 'request_id' identifies it in the Logs tab of Galon AI. ai_request_pending_review: the outcome of that request is being reconciled. ai_request_cancelled: that request was cancelled before the model was called. idempotency_conflict: the key was already used with a different body. Generate a new unique key (for example a UUID) for each new request. Reuse a key only to learn what happened to a request whose response you lost; to repeat a request that succeeded, use a new key.
402 ai_budget_exhausted or ai_request_exceeds_limit while your balance is positive.
These are not about your balance. ai_request_exceeds_limit: the upper estimate of this one request (input plus max_tokens) is above the spending ceiling per request that Galon sets. ai_budget_exhausted: the project reached the daily or monthly spending ceiling that Galon sets for Galon AI (UTC day and month). When spending limits per key are available in your console, 402 ai_key_limit_reached means the key reached the limit set for it. For ai_request_exceeds_limit, lower max_tokens or shorten the input, then send the request with a new Idempotency-Key: a top-up does not change this ceiling. For ai_budget_exhausted, wait for the next UTC day or month, or contact support to review the ceiling. For ai_key_limit_reached, raise the key's limit in the console or use another key.
400 ai_field_not_supported, ai_parameter_invalid, ai_streaming_not_supported or ai_model_capability_unsupported, often right after switching an existing client to Galon AI.
Galon refuses fields it does not support instead of ignoring them. The error names the field in 'field' and, for most codes, says what to change in 'message'. Common causes: a client library that sends extra fields (user, logprobs, tools, response_format), n greater than 1, both max_tokens and max_completion_tokens, a message with a name field or a role other than system, user or assistant, or stream: true for a model served without streaming. Remove or fix the field named in 'field', using the OpenAPI contract, then send the request with a new Idempotency-Key. Do not retry it unchanged.
A 200 reply has finish_reason length and an empty content, with a notice whose code is ai_output_empty_max_tokens (header X-Galon-Notice).
The model reached max_tokens before writing any output. Reasoning models spend output tokens before they write, so a small max_tokens can be used up entirely. The model did the work: the request is billed at the tokens it reports in usage, like any reply, and notice.billed_usage repeats them. Nothing is hidden and nothing is charged beyond the reservation. Raise max_tokens (or max_completion_tokens), then send the request again with a new Idempotency-Key: the first one is recorded. To keep costs low, set max_tokens to the length you need plus room for reasoning.
Galon Mail Pro
Help for Galon Mail Pro, hosted professional mailboxes on your own domain, used with IMAP and SMTP mail apps. It covers domain setup and DNS, mailboxes and aliases, mail app settings, billing from the prepaid balance and the most common errors.
How do I set up Galon Mail Pro on my domain?
1. In the console, open All services > Galon Mail Pro > Domains and add your domain (API: POST /v1/mail-pro/domains). 2. Publish the verification TXT record shown (_galon-mailpro.<your domain>) at your DNS host, then click Verify now (API: POST /v1/mail-pro/domains/<id>/verify). Once the record is seen, the domain becomes active. 3. Publish the other records shown: MX (to receive), SPF and DKIM (to send), and the recommended DMARC and autoconfiguration records, then verify again: the summary tells you when receiving and sending are ready. 4. Open Mailboxes and create a mailbox with a password, or with an activation link for the person who will use it. Verifying a domain is free; the plan of a domain starts with its first mailbox.
Which access do I need to manage Mail Pro with the API or an AI assistant?
With an API key, use the scopes mailpro:read (list and read) and mailpro:write (add domains, create and change mailboxes, aliases, passwords). The key's project is the project of the domains and mailboxes. In the console, administrators and developers of the project manage Mail Pro. An AI assistant connected with OAuth can hold mailpro:write; what it spends (a mailbox that starts a domain plan, a 25 GB option) counts against the spending limit a person sets for that app in Connected apps. A key without the scope gets 403 scope_missing; an id from another account or project is not found (404).
How do I set up a mail app or phone with a Mail Pro mailbox?
Open Galon Mail Pro > Mail apps once a domain is verified: it shows the server and ports to use. Incoming mail is IMAP over SSL/TLS (port 993); outgoing mail is SMTP over SSL/TLS (port 465) or with STARTTLS (port 587). The username is the full email address and the password is the mailbox password. Mail apps that support automatic configuration find these settings from the autoconfig, autodiscover and SRV records, if you published them.
What are the limits of Galon Mail Pro?
At the time of writing: each mailbox gets a quota of 1, 5 or 10 GB, or 25 GB with the 25 GB option; the mailboxes of a domain share the storage included with the domain (100 GB); a domain holds up to 10,000 mailboxes, a limit against abuse (fair use); a mailbox has at most 30 aliases; a password has 12 to 128 characters; an activation link works once, within 72 hours. Sending is limited per mailbox and per domain each day (1,000 messages a day per domain); a message beyond the limit is refused, not queued. Galon Mail Pro is for person-to-person mail: send bulk or marketing mail with Galon Mail.
How is Galon Mail Pro billed?
Mail Pro is one plan per domain, paid from the project's prepaid balance in US dollars; mailboxes on a paid domain cost nothing more, except the 25 GB option, charged per mailbox and per month. The plan starts with the first mailbox of a domain: the first month is charged pro rata of the remaining days, then the plan renews on the first day of each month (UTC). You can choose a monthly or annual cycle per domain; a change applies at the next payment. The amount is shown in the console before you create the mailbox; prices are on the pricing page. Project spending caps do not stop Mail Pro charges, but each charge is recorded. Until Mail Pro is open for sale, creating a mailbox returns 503 mailpro.billing.off or mailpro.billing.price_not_configured.
What happens if my balance does not cover the renewal?
At renewal, the plans due and the 25 GB options of a project are charged together, all or nothing: if the balance does not cover the whole amount, nothing is charged and no debt is created. The mailboxes concerned (those of the domains due and those with an unpaid option) then show suspended_payment_required: sign-in and sending stop, while receiving and stored mail are kept. A domain whose plan is still paid is never suspended because of another one. While a mailbox is unpaid, no new mailbox can be created in the project (402 mailpro.billing.payment_required). Top up the balance; at the next renewal pass, the amount is charged and the mailboxes resume. A suspended unpaid mailbox cannot be resumed by hand. No deletion for non-payment is applied today.
How do passwords and activation links work?
When you create a mailbox, give either a password or ask for an activation link, not both. The activation link lets the person choose their own password; it can be used once and expires after 72 hours. Galon does not keep mailbox passwords. To reset a password, set a new one (POST /v1/mail-pro/mailboxes/<id>/password) or send a new activation link (POST /v1/mail-pro/mailboxes/<id>/activation-link); any older link stops working.
How do I delete a mailbox or a domain, and what happens to the mail when I leave?
Deleting a mailbox is reversible for 30 days: it shows pending_deletion, sign-in stops, and resume restores it before the date; after that it is deleted from the server. A domain can be removed only once its mailboxes and aliases are gone (409 mailpro.domain.has_mailboxes). When your account is closed, your mailboxes stay readable and exportable over IMAP for 30 days and are not charged; they are then deleted, followed by your domains. Export what you want to keep with your mail app before that date.
Can I move my existing email to Mail Pro without losing mail?
Galon never changes your DNS records for you: the records shown are what you publish at your DNS host. Until you change your MX record, mail keeps arriving at your current provider. A suggested order: verify the domain, create the mailboxes, copy your old mail over IMAP with your mail app, then change the MX record to the one shown and verify again; the domain summary shows receiving as ready once the MX record matches. Keep your old service until mail arrives in Mail Pro. Keep one SPF record only: the console proposes a merged value that replaces your existing ones.
A mail app or phone cannot connect: IMAP or SMTP sign-in is refused, or the connection fails or times out.
1. Compare your app's settings with Galon Mail Pro > Mail apps: server name, port 993 for IMAP, 465 (SSL/TLS) or 587 (STARTTLS) for SMTP. Port 465 needs SSL/TLS from the start; port 587 needs STARTTLS; mixing them fails. 2. The username is the full email address, not the part before the at sign. 3. Open the mailbox in the console and read its status: suspended, suspended_payment_required, pending_deletion and account_closed all block sign-in; provisioning means the mailbox is not ready yet. 4. A mailbox created with an activation link has no usable password until the person opens the link and chooses one. Fix the server, port and security settings, or set a new password (POST /v1/mail-pro/mailboxes/<id>/password). Resume a mailbox you suspended (POST .../resume); for suspended_payment_required, top up the balance (see Creating a mailbox or adding the 25 GB option returns 402 mailpro.billing.payment_required, or mailboxes show suspended_payment_required).
The domain stays pending_verification, or creating a mailbox returns 409 mailpro.domain.not_verified.
1. Open the domain in Galon Mail Pro > Domains and read the verification record: a TXT record named _galon-mailpro.<your domain> whose value starts with galon-mailpro=. 2. Check at your DNS host that the name is exactly that (some hosts add the domain again at the end: use the relative name shown) and that the value is copied whole. 3. DNS changes can take time to propagate; a resolver that does not answer leaves the status pending, never failed. Publish or fix the TXT record, wait for propagation, then click Verify now (POST /v1/mail-pro/domains/<id>/verify). Create mailboxes only once the domain is active.
Mailboxes are created but no mail arrives in them; senders' mail still reaches your old provider.
1. Verify the domain again and read the summary: receiving is ready only when the MX record matches the one shown. 2. Look up your domain's MX record at your DNS host: if it still points to your old provider, mail goes there. 3. Several MX records with different hosts split incoming mail between them. Replace the MX record with the one shown (priority 10), remove the old MX records once you are ready to switch, wait for propagation, then verify again.
Mail sent from a Mail Pro mailbox is refused, lands in spam, or the mail app reports that the message was not sent.
1. Verify the domain again: sending is ready only when the SPF record and every DKIM record are verified. DKIM records appear once the domain is active. 2. Two SPF records on the same name make SPF fail: keep one. 3. DMARC is recommended; if you already publish one, Galon keeps it. 4. If many messages were sent today, the daily sending limit of the mailbox or the domain may be reached: messages beyond it are refused, not queued. Publish the SPF value shown (it merges your existing SPF) and each DKIM record, verify again, and send bulk or marketing mail with Galon Mail, not from a mailbox. Wait for the next day if a sending limit is reached.
Creating a mailbox or adding the 25 GB option returns 402 mailpro.billing.payment_required, or mailboxes show suspended_payment_required.
1. Open Usage & billing > Balance and compare the project balance with the amount the console shows before the creation, or with the renewal shown in Galon Mail Pro > Billing. 2. Any unpaid mailbox in the project blocks new mailboxes, even if the balance now covers the new one. 3. If the request came from an app connected with OAuth, 402 mailpro.billing.connection_spend_limit means that app's spending limit is reached, not the balance. 4. 503 mailpro.billing.wallet_unavailable means the balance could not be read: nothing was charged. Top up the project balance in the console; unpaid mailboxes resume at the next renewal pass, and you can then create mailboxes again. For a connected app, a person raises its limit in Connected apps. For wallet_unavailable, retry the same request later.
A mailbox is full, or changing its quota returns 422 mailpro.storage.quota_exceeds_plan, 409 mailpro.storage.quota_below_usage or 503 mailpro.storage.capacity_reached.
1. Open the mailbox in the console (or GET /v1/mail-pro/mailboxes/<id>) to read its quota and current usage. 2. quota_exceeds_plan: the quota asked is above what the plan allows (10 GB, or 25 GB with the option, at the time of writing). 3. quota_below_usage: the mailbox already uses more than the new quota. 4. capacity_reached: the Mail Pro server is close to full; new mailboxes and quota increases are refused for a while, existing mailboxes keep receiving mail. Delete or archive old mail from the mailbox, or raise its quota (PATCH /v1/mail-pro/mailboxes/<id> with quota_mib) up to the plan's maximum; a quota above 10 GB adds the 25 GB option, charged from the balance. For capacity_reached, retry later.
Adding a mailbox, an alias or a domain is refused: 409 mailpro.identity.alias_conflict, mailpro.identity.alias_limit, mailpro.mailbox.limit_reached or mailpro.domain.unavailable.
1. alias_conflict: the address is already a mailbox or an alias in your organisation. 2. alias_limit: the mailbox already has 30 aliases. 3. mailbox.limit_reached: the domain reached its technical limit of mailboxes. 4. domain.unavailable: the domain is already attached to Galon Mail Pro, possibly by another account. 5. domain.not_found on an alias: the alias must use an active Mail Pro domain of your account. Pick another address, remove an unused alias, or add and verify the alias's domain first. For more mailboxes than the domain limit, ask for a quote. If your domain is attached elsewhere and you own it, contact support.
The activation page says the link is no longer valid (410 mailpro.auth.activation_invalid).
The link was already used, is older than 72 hours, or a newer link or a new password was set for the mailbox since; the page does not say which, on purpose. Ask an administrator of the project to send a new activation link from the mailbox page (POST /v1/mail-pro/mailboxes/<id>/activation-link), and open the newest link within 72 hours.