Developers

What can be bought, with its exact price and terms: the only prices that may be said to a customer. Amounts are whole agorot (9900 is 99.00 shekels).

This account's plan, when it renews, the saved card (brand and last four digits only), what is owed, and any charge in progress or in trouble. plan_change says what moving to each other plan would cost now and add, a move to a smaller plan that is waiting for the renewal, and any reason the plan cannot be changed now. A plan that was cancelled (cancel_at_period_end) works in full to the end of its paid month, and is kept, or moved from, only by the customer typing the card again on the secure page. A payment has succeeded only when a charge here says succeeded. frozen says the account is frozen for a disputed charge: calls are refused, no payment can be started and a payment page left open is closed, until a person at Telfluent lifts it; nothing here can.

The address of the secure payment page for a session, for the signed-in owner's own browser.

Where a payment session stands. The plan is active only when this says ready: not when the link was opened, and not when the customer says they paid.

Enterprise only: set the level, the number of minutes the balance is brought back up to at each charge, in seconds (whole minutes times 60). It charges nothing by itself and takes nothing back; it applies from the next charge. Never under the least or over the most that billing.summary shows under quota. Returns the summary.

Every line of money on this account, newest first: charges, payments, credits, refunds. Positive is owed, negative is paid or credited. What is owed is their sum. note is always null: the service's own bookkeeping text is not sent. note_code says what a plan's fee is, as a fixed code or null: first_month, renewal, plan_change.

The legal documents for this account's payments (tax invoice / receipt, and any correcting a refund), newest first: its state, and once issued its number and a link to it. The link is on this API's own address, opens the PDF, and stops working after a short time: every answer carries a new one. A document exists only when its state is issued; one being prepared has no number yet. No document can be made, changed or made again from here.

Send an EXISTING issued document again: by SMS to the account owner's own phone, or return its link. The link is on this API's own address and stops working after a short time (the one sent by SMS lives longer). It never creates a document, and there is no destination to give.

Who this account's documents are made out to: the legal name, the email they are sent to, and for a business its company number. Each is the value in force. stored says what the customer typed for the name and for the email: null there means nothing is typed, and the value in force is the account's own (the business name and the owner's email from sign-up).

A public body signs up for the government plan on the website. The account then waits until Telfluent approves it. Until approved nothing is interpreted or charged. No voice assistant.

Close the account for good. Only after the renewal of its plan was cancelled (or the plan stopped), with nothing owed, no payment open and the account not frozen. confirm is typed by the owner himself: never type it for a customer, and never suggest it. On an Enterprise account it must be the sentence "close account with no further claim permanently" (or its Hebrew form), and acknowledge must be true: the owner ticked that the minutes left are given up and that this phone and email can then open only a regular account. On every other plan it must be exactly what account.get gives under close.confirm: "delete-account-and-usage-is-not-refunded" while the paid month of the cancelled plan still runs, "DELETE" after it. No money is returned and no minutes are returned; on Enterprise the minutes left are given up with no further claim to them. The managers, workers, codes and settings stop, and every key of the account is revoked: this is the last answer the key gets. It cannot be undone. Nothing is carried over to another account. A closed Enterprise account's phone and email may sign up again for a new account of another plan, never for a new Enterprise plan; another plan's can sign up again as a new customer.

Details of the account this token belongs to. close is what the dashboard shows the close-account button by, on every plan but Enterprise (null there, and while payment is not set up): refused is the reason account.close would be refused now (close_not_cancelled while the renewal of the plan is not cancelled) or null when it can be asked for, and confirm is what the owner types into the box now. calls_refused is no_language while the account has no language (calls that need one are refused until language.add), else null; refused_callers says exactly who is refused then: the side of the employer on the in-person number (employer_side_doors), and the workers with a phone and no language of their own (workers_without_language, how many); a worker with a language of his own is not refused. Null while the account has a language, and where another refusal comes first (an account not active, a temp or a family account, an account the billing gate refuses, or an account with no minutes left whose overage is cut).

This Personal account’s orders of blocks: for each order its blocks and their seconds, the seconds used and left of each, whether a block was opened (used from its first second) or frozen, when the order ends (one clock from its purchase for all its blocks), and until when money back may be asked for on it. seconds_left is what calls may still use now: the soonest-ending minutes are used first, and no call runs past an order’s end. Minutes only: a block is never money.

Cancel only the renewal of the safety-training appendix. No money comes back. The appendix runs to the end of its paid period; then the account is plain Enterprise: the minutes stay, every safety ability and setting is gone.

Open an arm of a safety-training: instructor, place and date. Returns the day's join code. The link holds until 20:00 Israel time that day, or until the instructor closes.

Close a training arm. Builds the daily documentation package per worker (phone, language, declared name, press-1, answers as keys pressed: this phone pressed this key, not who held it, not proof of the whole training, not a certified translation). Kept 18 months.

List this account's safety-training arms.

Set the optional comprehension questionnaire: its questions and answers. It is not played until a human has checked its translation. Never presented as a certified translation or as proof of understanding beyond the key pressed.

Record that a human checked the questionnaire's translation for one language before use. Without this the questionnaire is not played.

Record a key pressed on the questionnaire. Proves this phone pressed this key. Does not prove who held the phone, understanding of the whole training, or a certified translation.

The daily documentation packages of one training arm, kept 18 months: per-worker logs. Identity numbers are not in them.

A worker joins today's training by the code: the language, the name said (read back), press 1. Identity numbers are not collected. Voice and words are not recorded. The link holds until 20:00 Israel time, or until the instructor closed.

Read this account’s private number and state. The code is never included. languages is the list in force, or null when the number was never set (interpreting is refused until the languages are chosen; null is not “all”). menu is the two switches (in_person, dial_out). renews_at is the next renewal (null while it waits for a number), cancel_at_period_end whether its renewal was cancelled (it then runs to ends_at and goes), and on the temp workers number minutes_left and minutes_used are its own minutes of the current period. With staff_id, waiting: true is that arm’s paid add-on waiting for a number; without it, the temp number’s.

Read the private number’s switch code on the owner dashboard.

Change the private number’s switch code on the owner dashboard.

Read the arm add-on’s price from the catalogue, before asking the owner to confirm buying it: the same quote billing.offers gives a plan. Starts nothing and charges nothing.

The six-digit code workers enter on their first call to join this account, how many phones may join, and how many have. worker.list shows who they are. managers: how many managers on the employer's side may have a phone (the owner is one; null is no limit), how many have, and the range the owner may set that number in himself with setting.set (both null: he cannot). On Enterprise there is no account code (null): each arm has its own, on staff.list.

Replace the join code. Phones already joined stay; the old code stops working for new ones. On Enterprise name the arm whose code it is (staff_id); on the other plans there is one code and nobody to name.

Every language the service knows, and whether it can be sold yet.

Languages this account has.

Add a language to this account. It takes the next free key on the phone menu (at most 9, one key each). Refused unless the language pair is available.

Set the key order of this account's languages: the first listed is key 1 on the phone menu. List every language the account has, each once.

Remove a language from this account. The last language of an account is not removed (last_language). One that workers use is removed, and they keep it: workers_keeping is how many workers of the account have that language still.

Workers registered on this account. On Enterprise each row says which arm the worker belongs to (staff_id; his number, short, is his number in that arm's list: two digits from 10, three, 100 to 999, after the 90th), the minutes his phone used this month, and under own_use what applies now to his own use of the in-person number: allowed or not, which level decided, the allocation and what he used of it. staff_id gives one arm's workers only.

Let one worker use the in-person number on their own, or stop them. Omit "allowed" to follow the account setting again (on Enterprise: to follow his arm).

Name a worker who joined by code, or set the gender that picks the voice speaking their words. Send only what changes. On Enterprise also: staff_id moves him to that arm's list, where he gets a new number (10 to 999); in_person_cap_minutes is his own monthly allocation: how many minutes a month he may use the in-person number on his own (null removes it).

Stop a worker from using the line. Takes effect on the next call. Asked again of a worker already removed it changes nothing: he stays removed since the first time.

Register someone on the employer side — a foreman or manager. With a phone he takes one of the plan's manager seats (code.get shows them) and is refused when none is left. A phone typed on the dashboard (sent by an owner's or a dashboard key) does not count until it is proven: a one-time code is texted to that number, and he is on staff.list only once that phone has called the line and keyed it, within 600 seconds; until then the answer is staff: null with phone_pending (the number, and the seconds) for a number that has no place yet, and an entry not proven in time is gone by itself. A phone already a worker, another account's person, or an arm manager of this account is refused at once (phone_registered): nothing is created, no text is sent, and the answer names no other account. An account whose typed phones (here and in staff.update) had 10 codes in the last 24 hours that were never keyed is refused the next (too_many_unproven_codes) and nothing is texted. On a call to the voice assistant the phone the owner says is the person's at once. On Enterprise he is an arm of the organization: there is no limit on arms, a phone is needed, and the arm gets a join code of its own for its workers.

Managers on the employer side of this account. is_owner marks the owner's own row, the one with the phone that signed the account up, and no other. key is what a worker presses to ring this manager on the other-phone number: "1" to "9" for the first nine with a phone, "10" to "20" for the tenth to the twentieth (after a first key of 1 or 2 the line waits a moment for a second digit); null for a manager with no phone. On Enterprise a worker rings his own arm with no menu. On Enterprise each is an arm: its join code, its allocations, the minutes its list used this month and how many workers with a phone are in it. cap_hard says whether the arm's allocation is hard (calls are cut at it) or soft (false, the default: past it the calls go on while the organization has minutes); cap_left_minutes is the allocation less what was used, below zero when a soft one is over.

Change a manager on the employer side: the name he is rung by, the gender that picks the voice speaking his words, his own language (the owner's is the one every email to him is written in), or his phone (not the owner's own; a new phone hears the recording notice on its first call). A new phone typed on the dashboard (sent by an owner's or a dashboard key) does not count until it is proven: a one-time code is texted to that number, and it is his only once that phone has called the line and keyed it, within 600 seconds; until then he keeps the phone he had, and the answer carries phone_pending (the number, and the seconds) for a number that has no place yet. A phone already a worker, another account's person, or an arm manager of this account is refused at once (phone_registered): nothing is changed, no text is sent, and the answer names no other account. On a call to the voice assistant the phone the owner says is his at once. Send only what changes. On Enterprise also the arm's allocations: cap_minutes is the minutes a month its whole list may use (the arm's own calls and its workers'); workers_in_person opens or closes its workers' own use of the in-person number; workers_in_person_cap_minutes is how many minutes a month each of them may use on his own. null removes an allocation, or goes back to following the account. cap_hard makes the arm's allocation hard (true: at the allocation the arm's own calls and its workers' own use are refused until next month, and a call in progress is ended after the five-minute notice) or soft (false, the default: the calls go on while the organization has minutes, the arm shows as over, and every minute is recorded under it). No allocation ever refuses a worker ringing his own arm. On Enterprise also call_max_minutes: the longest a call of this arm may run, its own calls and its workers'; null follows the organization's (setting.set), and with none set a call is at most 30 minutes. It is set to 120 minutes or fewer (more is refused call_length_max).

Stop someone on the employer side from using the line. Never the owner's own row (is_owner on staff.list): refused, by every key. On Enterprise refused while workers with a phone are in the arm's list: move them to another arm first. Asked again of a manager already removed it changes nothing: he stays removed since the first time.

Enterprise account: one arm, its monthly allocation and minutes used, and its current workers with the minutes each used under this arm this month. A moved worker is on its current arm; past calls stay with the arm recorded when each call began.

Enterprise account: calls counted under one arm, newest first, including calls by workers later moved away, and of an arm since removed. used_minutes is the minutes spent on each call. No prices or payment details.

Owner only: one arm's managers, so the owner's screen can say who is in. managers are the phones that have called the line and keyed the code: each row is id, staff_id, e164, added_at, state confirmed, and confirmed_at (ms, the time that phone keyed the code). pending are phones sent a code that have not yet called and keyed it, and whose code has not run out: each row is e164, sent_at (ms, when the code was texted), expires_at (ms), and state waiting_proof. A phone confirmed, replaced or past its time is not in pending. arm_not_found for no such active arm.

Owner only: text a code to a proposed arm manager. The manager is added only after calling the line from that phone and keying its code. A phone already a worker, another account's manager, or an arm manager of this account is refused at once (phone_registered): nothing is created, no text is sent, and the answer names no other account.

Owner only: remove one manager from one arm and end every dashboard session at once.

Owner only: who still waits to confirm on this account: typed staff phones and arm-manager invitations whose code was texted and not yet keyed, each with kind (staff or arm_manager), label (the manager or the arm), phone_masked (the last four digits only) and expires_at (ms). A reload of the dashboard keeps these rows; one confirmed, replaced or past its time is gone. This account's entries only.

Minutes remaining this period, and what has been used.

Every minute that moved, newest first. This is what answers "why is my bill this?". note is always null: the service's own bookkeeping text is not sent. note_code says what a row is, as a fixed code or null: plan_month, plan_change, load, money_returned, fault_minute ("a fault in communication: one minute not charged"), a row of 0 minutes for each such minute, with its call's call_id.

Open alerts: caller_refused (a known phone was turned away, with the reason) and seats_full (a right code, but no seat left on the plan). detail carries only what is the customer's to read; on the service's own housekeeping it is null.

Mark an alert as dealt with.

Per-account overrides currently in force.

Set a switch of this account. manager_seats: a whole number, only on a plan where code.get gives managers.raisable_to, from managers.min up to it, and never under managers.used (the managers seated now). On Enterprise worker_in_person is off until opened, and an arm or a worker may be set apart from it. worker_in_person: false stops workers using the in-person number on their own (on by default; they spend this account's minutes). call_accept_staff: false connects the owner or a foreman the moment they answer a worker's call, without pressing 1 (on by default). call_accept_worker: true makes a worker rung by the employer press 1 first (off by default: a worker just answers). With accept off, a voicemail can be interpreted and charged. call_max_minutes, on Enterprise only: the longest a call of the organization may run, a whole number of minutes, 120 or fewer (more is refused call_length_max; with none set a call is at most 30 minutes); an arm may be set apart from it (staff.update).

API tokens on this account. Token values are never shown again. may is what the owner switched on for a helper key (token.update), empty on every other key.

Create a token. role=agent makes a helper key. may switches on for it, at once, any of the three things a helper key does only when the owner said so for that key: audit.list (read the change log), token.list (list the keys), code.rotate (replace the join code). Left out, none.

Set what a helper key may do past its day-to-day work: may is the whole list from now on, of audit.list (read the change log), token.list (list the keys) and code.rotate (replace the join code); an empty list switches all three off. Nothing else can be switched on for a key: no money decision, and no key is made, changed or revoked by a helper key. Only for a live helper key (role agent) of this account that the owner made: an owner's key, a revoked key and the voice assistant's key on a call are answered as no key at all.

Revoke a token immediately.

Start changing the phone number or the email the owner signs in with: send one of the two, the new value. A one-time code goes to the OLD one (the phone or the email the account has now), and the answer is the same whatever the new value is: nothing is said of a number or an address until the old side is proven. The change is made only when both codes were given back with owner.contact.change.confirm, within 600 seconds of this answer. On Enterprise the person who signs for the organization is identified again first, on the secure identification page (billing.join.link gives its address): until that has passed this is refused and no code is sent. Refused on a frozen account. Never type a code for a customer.

Give back a code of a change started with owner.contact.change.start. The first right code proves the old phone or email: the answer is step: "new", and a second code has gone to the NEW one (refused here, and the change ended, when the new value already belongs to an account). The second right code proves the new one, and only then is the value changed: the answer is changed ("phone" or "email"). Both within 600 seconds of the start; five wrong tries end a code. With the change every key of the account is revoked, this one too: it is the last answer the key gets, and the owner signs in again with the new value. A notice of the change goes to the old value and to the new. Refused on a frozen account, as the start is: nothing is changed.

Who changed what, and when. Includes everything an agent did. actor is a key (token:…), a phone (phone:…), a sign-up or a sign-in, or system for everything the service did by itself. before and after carry the values that changed, never the service's own notes.