Moonshot AI/kimi-2.7-text-to-text

kimi-2.7-text-to-text

Free to try Kimi 2.7 Text-to-Text API for long-form writing, reasoning, coding help, summaries, and production LLM workflows through stable Flaq AI access.

Text Chat

Related Kimi 2.7 Models

kimi-2.7-text-to-texttext-to-text

kimi-2.7-image-to-textimage-to-text

Documentation

API Examples

JavaScriptPythoncURL

Submit Example

const response = await fetch('https://api.flaq.ai/api/v1/chat/completions', {
  method: 'POST',
  headers: {
    Authorization: 'Bearer YOUR_API_KEY',
    Accept: 'text/event-stream',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    model: 'kimi-2.7-text-to-text',
    messages: [
      {
        role: 'user',
        content: 'Write a concise Java beginner tutorial outline.'
      }
    ],
    stream: true,
    max_tokens: 2000,
    top_p: 0.9,
    top_k: 50
  })
});

const reader = response.body.getReader();
const decoder = new TextDecoder();
let buffer = '';
let assistantText = '';

while (true) {
  const { done, value } = await reader.read();
  if (done) break;

  buffer += decoder.decode(value, { stream: true });
  const frames = buffer.split('\n\n');
  buffer = frames.pop() || '';

  for (const frame of frames) {
    const lines = frame.split('\n').filter(Boolean);
    let eventName = 'message';
    const dataLines = [];

    for (const line of lines) {
      if (line.startsWith('event:')) {
        eventName = line.slice(6).trim();
      } else if (line.startsWith('data:')) {
        dataLines.push(line.replace(/^data:\s*/, ''));
      }
    }

    const raw = dataLines.join('\n').trim();
    if (raw === '[DONE]') {
      console.log('\nFinal text:', assistantText);
      continue;
    }

    let payload;
    try {
      payload = JSON.parse(raw);
    } catch {
      continue;
    }

    if (eventName === 'error' || payload.error) {
      const msg = payload.error?.message ?? payload.message ?? 'Chat request failed';
      throw new Error(msg);
    }

    const delta = payload.choices?.[0]?.delta;
    if (delta?.content) {
      assistantText += delta.content;
      console.log(assistantText);
    }
  }
}

Submit Example

import json
import requests

response = requests.post(
    'https://api.flaq.ai/api/v1/chat/completions',
    headers={
        'Authorization': 'Bearer YOUR_API_KEY',
        'Accept': 'text/event-stream',
        'Content-Type': 'application/json',
    },
    json={
        'model': 'kimi-2.7-text-to-text',
        'messages': [
            {
                'role': 'user',
                'content': 'Write a concise Java beginner tutorial outline.',
            }
        ],
        'stream': True,
        'max_tokens': 2000,
        'top_p': 0.9,
        'top_k': 50,
    },
    stream=True,
)

response.raise_for_status()

event_name = 'message'
assistant_text = ''

for raw_line in response.iter_lines(decode_unicode=True):
    if not raw_line:
        event_name = 'message'
        continue

    if raw_line.startswith('event:'):
        event_name = raw_line.replace('event:', '', 1).strip()
        continue

    if raw_line.startswith('data:'):
        raw_data = raw_line.replace('data:', '', 1).strip()
        if raw_data == '[DONE]':
            print('\nFinal text:', assistant_text)
            continue

        payload = json.loads(raw_data)

        if event_name == 'error' or payload.get('error'):
            error = payload.get('error') or payload
            raise RuntimeError(error.get('message', 'Chat request failed'))

        choices = payload.get('choices') or []
        if choices:
            delta = choices[0].get('delta') or {}
            content = delta.get('content')
            if content:
                assistant_text += content
                print(content, end='', flush=True)

Submit Example

curl -N -X POST "https://api.flaq.ai/api/v1/chat/completions" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: text/event-stream" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kimi-2.7-text-to-text",
    "messages": [
      {
        "role": "user",
        "content": "Write a concise Java beginner tutorial outline."
      }
    ],
    "stream": true,
    "max_tokens": 2000,
    "top_p": 0.9,
    "top_k": 50
  }'

Start a new chat

Send a message to begin.

Kimi 2.7 Text to Text Pricing

Parameters	Price	Original Price	Discount

Token: input	$0.8455 per 1M input tokens	$0.8900 per 1M input tokens	95%
Token: output	$3.5245 per 1M output tokens	$3.7100 per 1M output tokens	95%

README

Stable & Affordable Kimi 2.7 Text-to-Text API (Moonshot AI Language Model)

Kimi 2.7 Text-to-Text API on Flaq AI provides stable Moonshot AI language model access for developers building reasoning, writing, coding, summarization, and automation workflows. This affordable Kimi API integration helps teams generate reliable text outputs through a production-ready route without managing provider-specific infrastructure. It is designed for AI agents, business tools, content systems, and developer products that need responsive language intelligence at scale.

Key Features of Kimi 2.7 Text-to-Text API

Reliable Text Generation: Generate high-quality responses for writing, analysis, coding help, summaries, and structured business workflows through Kimi 2.7 API integration.
Strong Instruction Following: Build applications that need precise prompt adherence, multi-step reasoning, and consistent response formatting for production use.
Developer-Friendly API Access: Integrate Kimi 2.7 through a stable Flaq AI route with familiar request patterns for chat, automation, and backend services.
Conversation Context Support: Maintain useful context across multi-turn interactions for assistants, workflow copilots, and agent-style applications.
Practical Output Controls: Tune generation behavior for concise answers, deeper reasoning, creative writing, or structured outputs based on your product needs.
Affordable LLM Workflows: Use Kimi 2.7 for cost-effective language automation, internal tools, and scalable AI features without heavy infrastructure overhead.

How to Use Kimi 2.7 Text-to-Text API for Text Generation on Flaq AI

Input: Natural language messages, task instructions, conversation history, and optional generation preferences.
Output: Text responses suitable for chat assistants, summaries, analysis, coding support, and structured content workflows.
Context: Supports multi-turn conversation patterns for interactive applications and agent workflows.
Capabilities: Text generation, reasoning assistance, content drafting, code help, summarization, classification, and workflow automation through Kimi 2.7 API integration.

Best Use Cases for Kimi 2.7 Text-to-Text API Integration

AI Agents & Assistants: Power chatbots, workflow copilots, and task agents that need stable reasoning and instruction-following behavior.
Content & Writing Tools: Draft articles, rewrite copy, generate outlines, summarize long materials, and create polished user-facing text.
Developer Productivity: Build coding assistants, documentation helpers, debugging copilots, and code explanation tools with affordable API access.
Business Automation: Classify requests, extract meaning from messages, generate replies, and automate repetitive knowledge-work tasks.
Research & Analysis: Summarize source material, compare options, synthesize findings, and turn messy notes into structured outputs.

Note Please ensure your prompts and usage comply with Moonshot AI and Flaq AI safety requirements. If an error occurs, revise the request, remove restricted content, and try again.

Kimi 2.7 Text-to-Text vs Competitors: Comparative Analysis

Kimi 2.7 vs. GPT Text-to-Text
GPT models offer broad general-purpose language capabilities. Kimi 2.7 Text-to-Text API provides a Moonshot AI alternative for teams that want stable, affordable LLM access with strong reasoning and coding-oriented workflows.
Kimi 2.7 vs. Claude Text-to-Text
Claude is known for careful long-form writing and analysis. Kimi 2.7 focuses on practical reasoning, developer productivity, and cost-effective automation through a simple API integration.
Kimi 2.7 vs. Gemini Flash
Gemini Flash emphasizes fast Google model access. Kimi 2.7 gives developers a Moonshot-native route for language tasks where instruction following, coding help, and agent workflows matter.
Kimi 2.7 vs. Qwen Plus
Qwen Plus is a strong Alibaba language model for affordable chat workflows. Kimi 2.7 offers a separate Moonshot AI model choice for teams comparing output style, reasoning behavior, and provider diversity.
Kimi 2.7 vs. GLM 5.2
GLM 5.2 is positioned for advanced coding and agentic engineering. Kimi 2.7 provides another stable LLM option for writing, coding assistance, summarization, and general-purpose automation on Flaq AI.