标签：#API

Most "AI agent + email" tutorials start the same way: connect the agent to a human's inbox over OAuth, hope the token doesn't expire mid-run, and pray the agent never replies to the wrong thread on someone's behalf. There's a different model: give the agent its own email address. Nylas recently shipped Agent Accounts (currently in beta) — fully functional, Nylas-hosted mailboxes you create and control entirely through the API. Each one is a real name@company.com address that sends, receives, hosts calendar events, and RSVPs to invitations. To anyone interacting with it, it's indistinguishable from a human-operated account. I work on the docs at Nylas, so I've spent a lot of time with this API. Here's a tour of what it does and how to get a mailbox running in a few minutes. Why not just connect the agent to a human inbox? You can — that's what OAuth grants are for, and they're the right tool when the agent works on behalf of a person. But a lot of agent workflows want a first-class identity instead: System mailboxes ( sales@ , support@ , scheduling@ ) that your app owns end-to-end. No OAuth consent screen, no user offboarding breaking your integration. Ephemeral inboxes for test automation — provision a fresh address per run, sign up for a service, grab the OTP from the verification email, tear it down. Per-customer identities in multi-tenant apps: scheduling@customer-a.com , scheduling@customer-b.com , each with its own send quota and sender reputation, all in one Nylas application. A scheduling bot with its own calendar that proposes slots, sends invites, and shows up as a normal participant in Google Calendar, Microsoft 365, and Apple Calendar. The key design decision: an Agent Account is just another grant . It gets a grant_id that works with every existing Nylas endpoint — Messages, Drafts, Threads, Folders, Attachments, Calendars, Events, Webhooks. If you've already built against connected accounts, nothing new to learn. Create a mailbox with one API call Every

Working with modern APIs means living in JSON. But the moment your project touches a legacy enterprise system - a bank, a government service, or a SOAP endpoint that hasn't changed in a decade - you're suddenly dealing with XML. The challenge isn't just swapping syntax; it's understanding where the two formats are structurally incompatible, and what breaks silently when you ignore that. Why JSON and XML Don't Simply Map to Each Other JSON is compact and type-aware - it distinguishes between numbers, booleans, strings, and arrays natively. XML is verbose, treats all content as text, and has no concept of arrays. It only has repeated sibling elements. This gap is where most conversion bugs are born. A JSON array with just one item can silently become a plain object if your converter doesn't handle the edge case explicitly. The Three Biggest Conversion Pitfalls First is array ambiguity - XML has no array type, so a JSON array becomes repeated sibling elements. A single-item array is indistinguishable from a plain object unless your converter explicitly preserves the list context. Second is type erasure - XML flattens numbers, booleans, and strings into plain text, destroying the type information that many downstream systems depend on. Third is the single root element rule - JSON can have multiple top-level keys, but every valid XML document must have exactly one root element wrapping everything else. Handling Arrays the Right Way Always nest array items inside a named parent element. A JSON users array should produce a parent element containing individual child elements. This structure makes the list unambiguous to any downstream XML parser and prevents silent data loss during round-trips. Escaping Special Characters Characters that are perfectly valid inside a JSON string will break an XML parser immediately. Your conversion logic must escape these four: less-than becomes <, greater-than becomes >, ampersand becomes &, and double-quote becomes ". Skipping even one of

Connecting to a payment gateway rarely fails because of business logic. More often, it fails at the very first technical step: authentication. If you’ve ever worked with payment APIs, you know the drill. Before sending a single request, you need to generate a cryptographic key pair and sign every request correctly. Sounds straightforward—until you actually try to do it. The hidden hurdle in every integration To securely call the Payneteasy API, each request must be signed. That means: Generating an RSA key pair (usually via OpenSSL) Converting between PKCS#1 and PKCS#8 formats Building a correct signature base string Percent-encoding everything properly Signing with RSA-SHA256 or HMAC-SHA1 Assembling the Authorization header One small mistake—a missing character, wrong encoding, or incorrect format—and your request gets rejected. For teams without deep cryptography expertise, this step alone can turn a one-day integration into a week-long debugging session. If you’re curious, the full manual process is documented here: https://doc.payneteasy.com/integration/general_api_usage/request_authentication_methods/oauth.html#generating-key-pair The solution: Key Pair Factory We built the Payneteasy Key Pair Factory to remove this bottleneck entirely. Instead of dealing with OpenSSL commands and key formats, you can generate everything you need in just a few clicks. What it does: Generates a ready-to-use RSA key pair Ensures correct formatting for Payneteasy APIs Eliminates manual conversion and configuration errors Keeps the private key on your side Provides a public key for request verification No cryptography expertise required. The tool is open-source and available on GitHub: https://github.com/payneteasy/key-pair-factory Why this matters This is not just about convenience—it directly impacts integration speed and success. With the Key Pair Factory, you get: Faster onboarding Fewer integration errors Less back-and-forth with support teams A smoother developer experience I

I didn't set out to build a content API. I set out to stop copy-pasting. Every week, the same ritual: open a doc, stare at a blank page, write a headline, delete it, write it again. Multiply that by every client, every product page, every email drip campaign. I wasn't doing creative work — I was doing assembly-line work while pretending it was creative. PostAll started as a script I wrote to stop doing that. The API is what that script became after other developers asked if they could use it too. This guide walks you through integrating PostAll's API into your own workflow — authentication, the endpoints you'll actually use, real working code in both Python and Node.js, and the specific places things will break before they work. By the end, you'll have a functioning pipeline that generates formatted, CMS-ready content programmatically. What you'll build A script that takes a list of content briefs (keywords, tone, target length) and returns publish-ready content — with proper formatting, metadata, and error handling for the rate limits you'll hit in production. Here's the shape of what you're building: [ CSV of briefs ] → [ PostAll API ] → [ formatted content objects ] → [ your CMS / database ] The full working code for both languages is at the end of each section. I'll explain the interesting parts inline. Prerequisites A PostAll account with API access enabled (free tier works for this guide — rate limits noted below) Node.js 18+ or Python 3.10+ Basic familiarity with async/await in either language An HTTP client: axios or native fetch for Node, httpx for Python Step 1: Authentication PostAll uses API key authentication. Every request needs your key in the Authorization header. Get your key: Dashboard → Settings → API Keys → Generate New Key Store it as an environment variable. Never hardcode it. export PostAll_API_KEY = "postall_live_xxxxxxxxxxxxxxxxxxxx" Your key has two prefixes: postall_live_ for production, postall_test_ for the sandbox. The sandbox returns r

TL;DR — We'll install dskripchenko/laravel-api , write one controller, and end up with a versioned API ( /api/v1/... ) and interactive OpenAPI 3.0 docs at /api/doc — generated from the docblock you'd write anyway. Then we'll ship a v2 without copy-pasting a single controller. The problem Two things rot in every growing Laravel API: Versioning. v1 ships, then v2 needs to change three endpoints but keep the other twenty. You either copy-paste a V2 folder (and now bugfixes live in two places) or bolt if ($version === 2) branches into your controllers. Docs. The OpenAPI spec drifts from the code the moment you merge. Annotation libraries ( #[OA\Get(...)] , giant YAML files) ask you to describe your API twice — once in code, once in attributes. This package's bet: your controller already describes itself . The method name, the request fields, the response shape — write them once, as a normal PHPDoc, and let the package derive routes and docs from it. Versioning becomes plain PHP inheritance. Let's build it. What we'll build A tiny tasks API: POST /api/v1/task/list — list tasks POST /api/v1/task/create — create one interactive docs at GET /api/doc (raw spec per version at /api/doc/{version} ) then a v2 that adds an endpoint without touching v1 Total: ~4 small files. Step 0 — Install composer require dskripchenko/laravel-api Publish the config (optional, but handy to see the knobs): php artisan vendor:publish --tag = laravel-api-config // config/laravel-api.php return [ 'prefix' => 'api' , // → /api/... 'uri_pattern' => '{version}/{controller}/{action}' , 'available_methods' => [ 'get' , 'post' , 'put' , 'patch' , 'delete' ], 'openapi_path' => 'public/openapi' , 'doc_middleware' => [], // lock down /api/doc here ]; Step 1 — Write a controller Nothing exotic — it extends the package's ApiController , which gives you response helpers ( success() , error() , validationError() , created() , noContent() , notFound() ). The docblock is the documentation : <?php namespace App\Api

TLDR: we just launched free OpenClaw hosting. One-click deploy, no infrastructure to manage, only pay...

Every backend project I've worked on eventually hits the same wall. You start clean — one service, simple routes, everything works. Then slowly the requirements creep in. "We need rate limiting." "Can we add auth middleware?" "What happens when the user service goes down — does it take everything else with it?" You either bolt these things onto every service individually, copy-paste the same middleware across projects, or pay for a managed gateway like Kong or AWS API Gateway and hope it does what you need. I wanted to actually understand how these things work under the hood. So I'm building one — and this is what I've learned so far. What is Ferrox? Ferrox is a self-hosted, programmable API gateway written entirely in Rust. It sits in front of your backend services and handles everything a production system needs in one place: Dynamic routing — point any path prefix to any upstream service Authentication — JWT and API key validation on protected routes Rate limiting — Redis-backed per-IP and per-API-key limiting Circuit breaking — stops hammering a dead upstream service Response caching — Redis-backed TTL cache per route Real-time observability — WebSocket dashboard with live request stats Prometheus metrics — plug straight into Grafana The idea is simple. Instead of this: Client → Service A (has its own auth, rate limiting, logging) Client → Service B (has its own auth, rate limiting, logging) Client → Service C (has its own auth, rate limiting, logging) You get this: Client | v FERROX (auth, rate limiting, circuit breaking, logging — once) | +--------+--------+ | | | Svc A Svc B Svc C (clean) (clean) (clean) Your services stay clean. Ferrox handles the cross-cutting concerns. Why Rust? Honest answer — I already knew Rust from my backend work. But for a gateway specifically, it felt like the obvious choice. A gateway sits on the critical path of every single request. Every millisecond of latency it adds is latency your users feel. You need predictable performance

There is a file in almost every backend I have worked on. It generates PDFs. Invoices, mostly. Sometimes reports or certificates. It was written years ago by someone who left, it runs a headless browser nobody fully understands, and it falls over on the last day of the month when finance needs the invoices out. I have rebuilt this same haunted corner enough times that I decided to fix it once, properly, for everyone. It is called PDFPipe. The actual problem Generating a PDF from HTML sounds trivial until you run it in production at any scale. The usual path is a headless Chromium (Puppeteer, Playwright, wkhtmltopdf, or Gotenberg). Then you discover: Chromium wants 0.5 to 1 GB of RAM per instance and falls over under load. Cold starts add seconds to every request after a deploy. Custom fonts do not load, or load inconsistently. Tables split across page breaks in ugly ways. You now own a service that needs health checks, retries, and monitoring. None of this is your product. It is undifferentiated infrastructure that breaks at the worst possible time. What PDFPipe does One endpoint. You send HTML or a template plus JSON data, you get back a PDF. curl https://api.pdfpipe.xyz/v1/pdf \ -H "Authorization: Bearer pp_live_..." \ -d '{"html":"<h1>Invoice #4012</h1>","options":{"format":"A4"}}' \ --output invoice.pdf That is the whole integration. No browser in your infra, no queue to babysit. Three decisions I made on purpose Flat pricing. A lot of PDF APIs price in credits where one large document burns several. I find that hostile. A document is a document. A real free tier. The industry standard free tier is around 50 documents a month, which is not enough to ship anything. PDFPipe gives 500. Security as a feature, not an afterthought. HTML-to-PDF services are a textbook SSRF target. Rendered markup can embed an iframe pointing at file:///etc/passwd or the cloud metadata endpoint at 169.254.169.254 and leak credentials straight into the returned PDF. There are CVEs for ex

Azure API Management shipped a Unified Model API that lets clients speak one format while APIM transforms requests to Anthropic, Vertex AI, and other backends. Content safety policies now cover MCP tool calls and Agent-to-Agent payloads alongside LLM traffic. Token metrics expanded to track reasoning, cached, and audio tokens across providers. By Steef-Jan Wiggers

Anthropic shipped Claude Fable 5 on June 9, 2026 — its first generally available Mythos-class model, priced at $10 per million input tokens and $50 per million output. That is exactly double Claude Opus 4.8, and the benchmark deltas are real: SWE-Bench Pro 80.3% vs 69.2%, FrontierCode 29.3% vs 13.4%. But the price is not the migration story. The API behavior is. Fable 5 ships three breaking changes that will silently misbehave in any integration that assumes Opus-era semantics. This post covers what actually changes in your code, what the bill looks like, and where the traps are. I run model intelligence at TokenMix , where we track pricing and API behavior across 300+ models. Everything below is sourced from Anthropic's launch docs, migration guide, and pricing page — verified June 10, 2026. The 60-second version Price: $10/$50 per MTok. Every rate is exactly 2× Opus 4.8 — cache reads $1, 5-min cache writes $12.50, 1-hour writes $20, batch $5/$25. Specs: 1M context, 128K max output, no long-context surcharge. Model ID: claude-fable-5 on the Claude API; anthropic.claude-fable-5 on Bedrock; anthropic/claude-fable-5 on OpenRouter. Breaking change 1: Adaptive thinking is always on. thinking: {"type": "disabled"} returns an error. Breaking change 2: Refusals are HTTP 200 responses with stop_reason: "refusal" — not error codes. Breaking change 3: Safety classifiers reroute flagged requests to Opus 4.8 (under 5% of sessions), and rerouted requests bill at Opus rates. No ZDR: 30-day data retention is mandatory. Zero-data-retention accounts don't see the model at all. Breaking change 1: thinking is no longer optional On Opus 4.8 you could disable thinking to trade quality for latency. On Fable 5 you cannot — adaptive thinking is permanently on, and the model decides how much to think per request. Your replacement lever is the effort parameter: { "model" : "claude-fable-5" , "max_tokens" : 16000 , "effort" : "high" , "messages" : [ ... ] } Five levels: low , medium , high ,

Have you ever stared at two different medicine boxes, squinting at the tiny font of the active ingredients, wondering: "Can I actually take these together?" Modern healthcare is complex, and drug-drug interactions (DDI) are a leading cause of avoidable ER visits. In this tutorial, we’re going to leverage GPT-4o Vision , React Native , and the FDA OpenData API to build a "Drug Conflict Scanner." We will utilize multimodal AI to transform messy pill-box photos into structured data and cross-reference them against official medical databases for safety. By the end of this guide, you'll master GPT-4o OCR structuring and automated knowledge graph verification for real-world health tech applications. 🚀 The Architecture 🏗️ The logic flow involves capturing images of multiple medicine labels, using GPT-4o's multimodal capabilities to extract chemical compounds, and then querying the FDA's database for potential interactions. graph TD A[React Native App] -->|Capture Multi-Photo| B[Node.js Backend] B -->|Image Buffer| C[GPT-4o Vision API] C -->|Structured JSON: Ingredients| B B -->|Search Interactions| D[FDA OpenData API] D -->|Drug Labels & Warnings| B B -->|Safety Report| A A -->|UI Alert| E{Safe or Warning?} Prerequisites 🛠️ To follow along, you'll need: GPT-4o API Key (via OpenAI) Node.js (for our backend relay) React Native (Expo is recommended for camera access) An account at open.fda.gov (though the public API works for limited requests) Step 1: Extracting Ingredients with GPT-4o Vision Traditional OCR struggles with curved medicine bottles and shiny packaging. GPT-4o excels here because it understands context. We don't just want text; we want the Generic Name of the drug. The Backend Logic (Node.js) // backend/scanner.js import OpenAI from " openai " ; const openai = new OpenAI ({ apiKey : process . env . OPENAI_API_KEY }); async function analyzeMedicineLabels ( imageUrls ) { const response = await openai . chat . completions . create ({ model : " gpt-4o " , messages :

If you scrape Weibo's hot-search board you get a snapshot: ~50 trending topics, ranked, right now. That's table stakes — and on its own it's almost useless as a signal. The value isn't what is trending; it's what's moving : which topic just jumped 30 places in 20 minutes, which is decaying, which is brand-new this hour. That's velocity , and velocity is where the signal lives — for brand-crisis teams, consumer-trend desks, and anyone modelling attention in China. The catch: a single scrape can't tell you velocity. You have to diff the board against its own past, reliably, run after run. That's a stateful pipeline, and it has a few non-obvious gotchas. Here's the shape of the problem and how to handle it. Why a snapshot isn't enough Rank-right-now tells you nothing about trajectory. "#7" could be a topic on its way to #1 or one fading out of the top 50 — same row, opposite meaning. To act on a trend you need the derivative : direction, speed, and how long it's been climbing. None of that is in a single pull. The trending-delta problem Three things make "just diff the board" harder than it looks: Key by identity, not position. You can't track a topic by its rank — rank is the thing that changes. Key by the topic itself (its text/keyword) or your deltas are nonsense. State has to survive between runs. A scheduled scrape is stateless by default — each run starts cold. To compute "this rose 12 places since 30 minutes ago," you must persist the previous board and reload it next run, keyed so independent schedules don't overwrite each other. The board churns. Topics appear, peak, and fall off. You want each tagged new / rising / falling / steady / dropped , plus how long it's been on the board and its running peak — none of which exist in the raw snapshot. How to handle it (the pattern) current = pull_board () # [{topic, rank, heat}, ...] previous = load_state ( key ) # durable store that persists across runs for t in current : prev = previous . get ( t . topic ) # match o

OpenAI has shipped more developer-facing infrastructure in the first half of 2026 than in the prior two years combined. GPT-5.5 is live. The Agents SDK is production-ready. Codex hit 5 million weekly active users. And yet most of the coverage is about ChatGPT's chat UX. Let's skip that and talk about what actually matters: ChatGPT's biggest upgrade ever and what developers actually need to know in June 2026. What changed at the API layer, which features are production-grade versus demo-ware, and whether it's finally time to move workloads back from Claude or Gemini. I spent the last two weeks migrating an internal agent pipeline from the Chat Completions API to the new Responses API. The difference is not subtle. This isn't a model bump with a new blog post. It's a platform rearchitecture. ChatGPT's Biggest Upgrade: The Responses API Changes Everything Forget GPT-5.5 for a second. The single most important change for developers building on OpenAI is the Responses API . If you've been building with Chat Completions, you know the drill: you manage conversation history client-side, pass the full message array on every request, and bolt on your own tool-calling orchestration. The Responses API eliminates most of that. Three things that actually matter: Server-side conversation state. OpenAI manages conversation history for you now. No more serializing and replaying message arrays on every call. For long-running agentic sessions, this alone cuts your infrastructure code in half. The reasoning_effort parameter. You can tell the model, per request, how much compute to burn on chain-of-thought reasoning before answering. Low effort for latency-sensitive paths like autocomplete and classification. High effort for accuracy-critical ones like analysis and code generation. Neither Claude nor Gemini expose anything equivalent at the API level right now. Background Mode. This is the one that changes architectures. Fire off a long-running task. Get results via webhook callback ins

สรุปสาระสำคัญ (TL;DR) ตัวแปรที่ตั้งค่าระหว่างการรันคำขอแบบแมนนวลใน Postman อาจ “หายไป” เมื่อรันผ่าน Collection Runner เพราะขอบเขตตัวแปรและพฤติกรรมการคงค่าระหว่างการรันไม่เหมือนกัน จุดที่ต้องตรวจสอบคือ pm.environment.set , การเลือก Environment, ค่า Initial/Current Value, ตัวเลือก “Keep variable values” และการเลือกใช้ Collection Variables ให้เหมาะกับสถานะภายในรันเดียวกัน ลองใช้ Apidog วันนี้ บทนำ คุณอาจเคยเจอสถานการณ์นี้: รันคำขอ Login ใน Postman แบบแมนนวล Post-response script ดึง access_token ตั้งค่า token ด้วย pm.environment.set คำขอถัดไปใช้ {{token}} ได้ตามปกติ แต่เมื่อกด Run Collection คำขอ Login ผ่าน แต่คำขอถัดไปได้ 401 Unauthorized ตัวอย่างสคริปต์ที่มักเป็นต้นเหตุ: pm . environment . set ( ' token ' , pm . response . json (). access_token ); สคริปต์นี้ไม่ได้ผิดเสมอไป แต่จะมีปัญหาเมื่อ: ไม่ได้เลือก Environment ใน Runner Runner รีเซ็ตค่าหลังรันเสร็จ ใช้ Environment Variables ทั้งที่ต้องการแค่ state ภายใน Collection Run ตั้งค่าเฉพาะ Current Value แต่ไม่ได้ตั้ง Initial Value บทความนี้สรุปวิธีดีบักและแก้ไขแบบลงมือทำได้ทันที ลำดับชั้นขอบเขตตัวแปรของ Postman Postman แก้ค่า {{variable}} ตามลำดับความสำคัญดังนี้: Local variables — ใช้เฉพาะในสคริปต์ที่กำลังรัน Data variables — มาจากไฟล์ CSV/JSON สำหรับ data-driven test Collection variables — ใช้ภายในคอลเล็กชัน Environment variables — ใช้ใน Environment ที่เลือก Global variables — ใช้ได้ข้ามคอลเล็กชันและ Environment ถ้ามีตัวแปรชื่อเดียวกันหลายขอบเขต เช่น token Postman จะใช้ค่าจากขอบเขตที่มี priority สูงกว่าก่อน ตัวอย่าง: pm . collectionVariables . set ( ' token ' , ' collection-token ' ); pm . environment . set ( ' token ' , ' environment-token ' ); console . log ( pm . variables . get ( ' token ' )); pm.variables.get('token') จะคืนค่าตามลำดับ priority ไม่ได้หมายความว่าจะอ่านจาก Environment เสมอไป ทำไมตัวแปรจึงหายไปใน Collection Runner 1. Current Value และ Initial Value ไม่เหมือนกัน ตัวแปรใน Postman มี 2 ค่า: Initial value : ค่าที่ซิงค์และแชร์กับทีม Current value : ค่า local ในเครื่องของคุณ เมื่อใช้: pm . environment . set (

Tóm tắt Nếu thay đổi gói miễn phí của Postman khiến bạn mất quyền truy cập vào workspace được chia sẻ, dữ liệu của bạn chưa chắc đã bị xóa. Việc cần làm là phục hồi càng sớm càng tốt trước khi cache cục bộ, quyền API hoặc bản sao lưu còn sót lại không còn dùng được. Bài viết này hướng dẫn các cách lấy lại collection/environment từ Postman và nhập chúng sang Apidog để giảm rủi ro bị khóa dữ liệu trong tương lai. Dùng thử Apidog ngay hôm nay Bối cảnh Sau bản cập nhật gói miễn phí Quý 1 năm 2026 của Postman, nhiều developer dùng workspace chia sẻ với đồng nghiệp phát hiện rằng họ không còn truy cập được dữ liệu nhóm. Các collection nằm trong workspace team, thay vì workspace cá nhân, đột nhiên bị khóa sau paywall. Một developer mô tả trên Reddit: “Tôi đến làm việc vào thứ Hai và toàn bộ không gian làm việc của nhóm tôi đã biến mất. Ba tháng với các bộ sưu tập, môi trường được sắp xếp gọn gàng, tất cả đều biến mất. Chỉ còn cách trả tiền thì mới có lại.” Điểm quan trọng: dữ liệu thường không bị xóa ngay. Postman lưu dữ liệu workspace phía server, còn việc bạn không nhìn thấy collection là hạn chế quyền truy cập. Vì vậy, hãy xử lý theo thứ tự dưới đây, ưu tiên các nguồn có khả năng còn dữ liệu đầy đủ nhất. 1. Kiểm tra cache trong ứng dụng Postman desktop Trước tiên, mở Postman desktop app nếu bạn đã từng dùng nó. Không mở bản web tại app.getpostman.com . Ứng dụng desktop có thể còn cache cục bộ của collection và environment bạn truy cập gần đây. Cache này thường chỉ tồn tại trong thời gian ngắn, tùy hệ thống và cơ chế invalidation của Postman, nên hãy xuất dữ liệu ngay nếu còn nhìn thấy. Các bước thực hiện: Mở Postman desktop. Kiểm tra tab History để xem các request gần đây. Kiểm tra sidebar bên trái xem collection còn hiển thị không. Nếu collection còn hiển thị, xuất ngay từng collection. Cách export collection: Nhấp chuột phải vào collection hoặc bấm menu ba chấm. Chọn Export . Chọn định dạng Collection v2.1 . Lưu file .json ra thư mục an toàn. Nếu collection vẫn hiển t

TL;DR If Postman’s 2026 Q1 free plan change blocked access to shared collections, your data may still be recoverable. Start with your Postman desktop cache, then check exports, admins, the Postman API, and logs. Once you recover the JSON files, import them into Apidog so your team has a safer workflow going forward. Try Apidog today Introduction After Postman’s 2026 Q1 free tier update, many developers found that shared workspaces were no longer accessible on the free plan. Collections that lived in team workspaces, instead of personal workspaces, became locked behind a paid plan. One developer described it on Reddit: “I came in on Monday and my whole team workspace was gone. Three months of organized collections, environments, all of it. Just gone unless we pay.” In most cases, the data is not immediately deleted. Postman stores workspace data server-side, and the issue is usually access restriction rather than deletion. That said, recovery is time-sensitive because local cache, API access, and workspace availability may not last. Use the steps below in order. 1. Check the Postman desktop app cache first Start with the Postman desktop app, not the web app. The desktop app may still have cached copies of recently opened collections and environments. Even if your server-side access is revoked, the local cache can sometimes keep enough data available to export. Steps Open the Postman desktop app. Do not use the web app at app.getpostman.com . Check the left sidebar for your collections. Open the History tab to confirm which endpoints you recently used. If collections are visible, export them immediately. To export a collection: Right-click the collection or open the three-dot menu. Select Export . Choose Collection v2.1 . Save the file locally. Repeat for every visible collection. If the collection appears but export fails, try working offline: Click your avatar in the top-right corner. Select Go Offline . Retry the export. Going offline can prevent the app from refre

Em resumo Variáveis definidas em scripts do Postman podem “sumir” quando você troca a execução manual pelo Collection Runner. Na prática, quase sempre é um problema de escopo: pm.environment.set escreve no ambiente ativo, variáveis de coleção têm outro ciclo de vida, e o runner pode descartar alterações ao final da execução. Experimente o Apidog hoje Neste guia, você vai ver como diagnosticar o problema, escolher o escopo correto e corrigir os casos mais comuns. Também verá como o Apidog lida com variáveis de forma mais explícita na interface. Introdução Você testa uma API manualmente no Postman: Executa a requisição de login. Um script salva o token. As próximas requisições usam {{token}} . Tudo funciona. Depois você clica em Run Collection . O login retorna sucesso, mas a próxima requisição falha com 401 Unauthorized . O token não foi encontrado. Esse comportamento é comum porque o modo manual e o Collection Runner não lidam com o estado das variáveis exatamente da mesma forma. A correção começa entendendo a hierarquia de escopos do Postman. Hierarquia de escopo de variáveis do Postman O Postman resolve variáveis seguindo uma ordem de prioridade. Da maior para a menor: Variáveis locais : existem apenas durante a execução do script atual. Variáveis de dados : vêm de arquivos CSV ou JSON usados em execuções orientadas por dados. Variáveis de coleção : pertencem à coleção e podem ser usadas por requisições dentro dela. Variáveis de ambiente : pertencem ao ambiente selecionado. Variáveis globais : ficam disponíveis para qualquer coleção e ambiente. Quando você usa: {{token}} o Postman procura token nessa ordem e usa o primeiro valor encontrado. Isso significa que o problema nem sempre é “a variável não existe”. Às vezes ela existe, mas em outro escopo, ou um escopo de maior prioridade está sobrescrevendo o valor esperado. Por que as variáveis desaparecem no Collection Runner 1. Valor inicial vs. valor atual Cada variável no Postman pode ter dois valores: Valor inicial

If you’ve tried building AI applications, you often face a familiar engineering wall. It goes like...

In the previous article, we connected our FastAPI application to a database using SQLite and SQLAlchemy. We also used classes like: class StudentCreate ( BaseModel ): name : str department : str cgpa : float without fully understanding what was happening behind the scenes. Today, we'll fix that. If you haven't read it check it out: FastAPI for AI Engineers - Part 3: Connecting to a database Ananya S Ananya S Ananya S Follow Jun 6 FastAPI for AI Engineers - Part 3: Connecting to a database # ai # fastapi # python # backend 6 reactions Add Comment 6 min read Why Do We Need Data Validation? Imagine you're building a weather application. A user asks: What is the temperature in Chennai? A valid response might be: 35 or 35°C But what if the API returns: Sunny This is clearly wrong. Temperature should be represented as a number. Even if the value itself is inaccurate, we still know that temperature must be numeric. This is where validation becomes important. Validation allows us to define rules about what data is acceptable before it enters our application. For example: Temperature should be numeric Age cannot be negative CGPA should be between 0 and 10 Email addresses should follow a valid format Without validation, applications can receive invalid data and behave unexpectedly. The Problem Without Validation Consider a student registration API. @app.post ( " /student " ) def create_student ( student ): return student A user could send: { "name" : "Ananya" , "cgpa" : "Excellent" } The API would accept it. But a CGPA should be a number, not text. As applications grow, manually checking every field becomes difficult. We need a better solution. Enter Pydantic Pydantic is a Python library used for data validation. FastAPI uses Pydantic extensively behind the scenes. Instead of manually validating data, we define a schema. from pydantic import BaseModel class Student ( BaseModel ): name : str cgpa : float Now FastAPI knows: name must be a string cgpa must be a floating-point nu

Quick share. Been running into this enough times across NetSapiens deployments that it's worth flagging. Scenario: Call gets placed or transferred between two domains on the same NetSapiens platform. The call connects fine. Audio works. But the caller ID showing up on the receiving side is wrong. It's showing the local extension or domain user instead of the actual originating caller. If you check the NetSapiens Known Issues page, this maps to NMS-2518. It shows up specifically when calls cross domain boundaries during hold or transfer. The fallout is mostly cosmetic but it matters for anyone running multi-tenant reseller deployments. Your customer sees the wrong name in their call history. Voicemail attribution gets weird. Inter-domain analytics show calls from the wrong source. A few patterns I've seen work around it: Configure SIP header rewriting at the SBC layer to preserve the original From URI across domain hops For softphones that pull call history from NetSapiens API directly, verify which field the client is actually displaying. Some pull from orig_user , others from local_user . The discrepancy shows up clearer than you'd expect. If you're running a mobile softphone client, check whether the client is caching contact info locally and overriding what NetSapiens returns. A lot of "wrong caller ID" reports turn out to be client-side caching bugs, not platform bugs. The deeper fix is platform-side and depends on what NetSapiens version you're running. The cleaner softphone integrations route call history through the NetSapiens API rather than building it locally on the device, which sidesteps the worst of this behavior. White-label softphones that integrate natively with NetSapiens handle this more consistently than generic SIP clients. Tragofone is one example where the call history syncs through the NetSapiens softphone integration layer directly, so inter-domain caller ID is consistent with what the platform actually has. Other native integrations handle t