What is Reddit's opinion of Postman?

From 3.5 billion Reddit comments

You can add your Mom as an actor if you'd like but it will require some doing.

This is the url to add an actor.

/library/sections/31/all?actor%5B0%5D.tag.tag=Mom&type=1&actor.locked=1&id=109328

31 this is the section or library ID number. Visit any Plex library and this value will be in the url.

id=109328 this is the rating key. Visit any Plex item and this value will be in the url.

Use a tool to call a PUT command (curl, Python with requests or urllib, or Postman) to run:

http://127.0.0.1:32400/library/sections/{LIBRARY_ID}/all?actor%5B0%5D.tag.tag={CUSTOM_ACTOR_NAME}&type=1&actor.locked=1&id={RATING_KEY}&X-Plex-Token={YOUR_PLEX_TOKEN}

Or with Python and the plexapi library:

from plexapi.server import PlexServer PLEX_URL = '' PLEX_TOKEN = '' plex = PlexServer(PLEX_URL, PLEX_TOKEN) actor = "Mom"

for item in plex.library.section('Home Videos'): item._edit_tags(tag="actor", items=[actor])

This will add your Mom to every item in your Home Videos library. I haven't figured out actor pictures/avatars or adding their roles yet but this is what it will look like

If by endpoints you mean URI's:

• Postman is a good GUI for that.
• <code>requests</code> and it's async counterpart <code>aiohttp</code> are good Python libraries for HTTP requests

Some details that will help us to help you:
- What API Are you using?
- What exactly are you struggling with? Building the cURL? Troubleshooting error codes? Scripting for the mass sms?
- What do you have done so far and what have you got working?

If you have no idea where to start, start by reading up on APIs and using cURL with FileMaker. A few Google searches will get you some helpful blogs.

Make sure you read through the API documentation for what endpoints to make the call to and what cURL details need to be provided (keys, authorization codes, request type, etc).

Try using a program like Postman (https://www.postman.com/) to get successful API calls before you start building it in FileMaker. Once you have it working there, you have all the information you need to pass through FileMaker to make the call correctly. Troubleshooting API requests in FileMaker can be time consuming and tedious.

if you have an API key you can make direct calls to the hypixel api, (my hypixel command)

using your requesting method of choice you can then make an API call to https://api.hypixel.net/player?uuid=${uuid}&amp;key=${api_key} and then check the Response for players (I recommend making a test request using postman)

if you need any more help or have any questions feel free to msg me on discord Fish#2455 :D

Yeh it’s free to create an account. Not sure what the commercials are like for using it in larger teams etc (not looked into it) but I have a free account and use it for the odd bit of development here and there (I’m a network engineer usually!)

https://www.postman.com/downloads/

Make sure you use the app version rather than the web client.

As for its usage - it has a whole host of amazing use cases and actual software developers can use it for all sorts of things like automated testing etc…

I use it as more like a “query builder” so I can piece together a URI, method, any auth & additional headers, test it, then export it as code once I know it works.

Maybe checkout Postman. You can use this to make API calls and it will capture response times/codes/body and you can then save these responses.

Edit: As a side note, for someone who isn't skilled at coding I'm impressed that you've heard of DevOps.

We use AWS Code* services mostly.

So CodeCommit for a git repo. Check in, triggers a CodeCommit Pipeline to pull the source, push the artifact to a CodeBuild. If you can script it, you can automate there. Generally will do an npm update, can run an npm audit if you like, lint and unit tests. Any of those fail, they fail the CodeBuild step, and it triggers a notification into Slack. If that all succeeds, proceed to the deployment step. That succeeds, fire another CodeBuild. For API's we've started to use Postman to automate the testing, for front ends we've started to use Cypress. The details are all in flux depending on project requirements or what we need/want to test.

Have not tried to connect with GSX. Lots of FileMaker devs test drive API connections in Postman, and then when they get everything figured out, transplant to FileMaker.

Some developers have posted Postman collections, such as this collection from Lesterius. Grabbing some of those collections and running them will acquaint you with how API interactions work, and then you can try to Map that experience to the GSX API.

Google My Business API is Restful

so you will be using a lot of json_decode($curlresponse, true) to get associative arrays you can work with, and json_encode($myArray) to post data.

basic cURL PHP example

I really like postman for testing my interactions with API’s. It even has an export request to PHP-curl option, but over use of that can lead to some dirty code.

A good way to practice using API's is to use postman. It is a tool that lets you make requests to APIs. You can pass in inputs, and get the response back. This way you know if there are any issues, they are with the actual request and not other parts of your code. Once you understand how the API works, it will be much easier when doing it inside code.

Typically for commercial web sites you will need to use an API they provide to allow programmatic access to their features. This usually requires registering to get an 'api key' or similar credential that you can use to authenticate and prove you are someone they know about and trust.

For your example of Giphy, they provide an API and documentation on how to work with their site. See this link, which gives access to their Software Development Kit (SDK) and other information: GIPHY Developers

For instance, here is their endpoint for uploading files: GIPHY Developers

These days typically most of these kinds of sites expose a web API that requires making HTTP requests to an HTTP endpoint, so in your programming language of choice you will need to make HTTP GET, POST and similar requests with all of the necessary fields filled out. You would usually use an existing library for this.

If you are starting to try and work with such APIs, use Postman | The Collaboration Platform for API Development to get everything working and then you can use that knowledge to make similar requests in your language of choice.

So, I don't know what's in the crypto object or why you're multiplying it's properties by the amounts but... in general the code itself looks above board. Maybe try just hitting the endpoint purely with a tool like Postman to make sure it's not your front end request being misconfigured 🤷‍♂️ If you post an actual Git repository or recreation of the logic, I could help test it further

For the best list of public APIs check out the Postman API Network. I'm part of the team looking to expand it and happened upon your post. You can even list your own public APIs as well!

https://www.postman.com/Prkkiller/workspace/redit/collection/6300399-ab994d00-770a-44ce-934e-d2331421dc8d?ctx=documentation

Thanks for the recommendation, it was the formating. Couldn't figure out exactly how to work it with `httr` (due to my lack of experience with it most likely), but ended up using [Postman](https://www.postman.com/) to generate the code and running it inside the `system()` function.

Neonova is a web app that allows contracts invocation specifying the type of invocation (read, write), the contract, operation and arguments and directly see the results.
The project is production ready and integrates our other wallet package, the Neo-Wallet-Adapter, so that it may serve also as a production example project to be kept as a reference for devs.
We hope it may be a seed for an useful open source tool like Remix (https://remix.ethereum.org/) for Ethereum or Postman (https://www.postman.com/).

<strong>Lost in Space</strong> - I made my first virtual escape room for people who know code. It's a bit challenging for non-native English speakers. But I would love some feedback.

Another way of testing is using https://www.postman.com/

That way to can be specific if you're making a GET/POST/PATCH/... call

Another way (less used) is becoming familiar with CLI curl command, but I would recommend trying with postman first and see if it's the same response 404

Try running the discord webhook directly via Postman, it will tell you, hopefully, an error code you can do something with, or at least let’s you quickly tweak the request until it’s correct.

https://www.postman.com/

We do have a couple of Postman collections, but not for making calls yet. You can see the collections here: https://www.postman.com/twilio?tab=collections

The collection does give you a good idea of how to set things up, the auth should be Basic Auth and the username is your Twilio Account Sid and the password is your Auth Token. The send an SMS request is then very similar to making a call. It will show you where to put the URL and how to interpolate your Account Sid using a path variable. It also shows how to add parameters in the body of the request. Hopefully that helps a bit! Otherwise, /u/Stunning_Reach_3884's suggestions are great too.

When you set up the make web request in IFTTT what are the settings? Method? Content Type? Etc…

I know my Wio Link API was picky about the content type, and thankfully the GET or POST methods were well documented in the Seeed documentation.

Might pay to try the discord webhook in Postman and see what ends up working. https://www.postman.com/

Application/json will most likely end up being the content type and I’m betting the method would be POST.

You could use Postman tool to call the Azure DevOps REST API quickly and easily. Don't need to format the code, just copy the example request body to the body tab(click raw and select Json format). Hope it helps.

Just gave it a spin here. I am not experiencing the AI pronouncing "." as "dot". Once you have the service initialized head over to the "Getting Started" section, and select "Show Credentials". It talks about leveraging the command-line but if you are not comfortable using the command-line you could consider installing a tool like Postman where-in you could select New -> HTTP request and populate the request along the following lines of https://imgur.com/a/lNNZti8

URL next to the verb POST in the screenshot is your instance URL
Password <-> API Key

Hope this helps.

To properly configure the plugin settings in homebridge you have to get your authentication token from the sync box. To get the token, you have to send a “post” request twice to the hue sync box. I used the “postman” app that you can download on a desktop:

https://www.postman.com

This will allow you to generate your post request to the sync box using it’s IP address and the parameters listed in the GitHub instructions.

Hey, I see the API here - https://www.postman.com/api-evangelist/workspace/uber/api/cd06ffe5-b65a-414d-926d-a1dc73bbe49e?version=6c3dc993-9475-423e-9afa-2cefb294795f&amp;tab=overview. You should be able to browse through the API definition under the Define tab.

There are infinit ways to call APIs, for development purposes I recommend you Postman.

Either way you will have to send your ApiKey in the Authorization header in your requests. Simple example with a Curl request :
curl -H "Authorization: %API_KEY%" https://api.pathfinder2.fr/v1/pf2

Recreate your request in Postman then click "code" - It will then give you examples you can play around with, including in PHP.

<?php require_once 'HTTP/Request2.php'; $request = new HTTP_Request2(); $request->setUrl('https://api.anything.com'); $request->setMethod(HTTP_Request2::METHOD_POST); $request->setConfig(array( 'follow_redirects' => TRUE )); $request->setHeader(array( 'Authorization' => 'Bearer xxx', 'Content-Type' => 'application/json' )); $request->setBody('{\n "prompt": "Human: Hiiiiiiiii.\nAI:",\n "temperature": 0.9,\n "max_tokens": 150,\n "top_p": 1,\n "frequency_penalty": 0.0,\n "presence_penalty": 0.6,\n "stop": [\n "\n",\n " Human:",\n " AI:"\n ]\n}'); try { $response = $request->send(); if ($response->getStatus() == 200) { echo $response->getBody(); } else { echo 'Unexpected HTTP status: ' . $response->getStatus() . ' ' . $response->getReasonPhrase(); } } catch(HTTP_Request2_Exception $e) { echo 'Error: ' . $e->getMessage(); }

Ah ok. So you probably want to use a service to help do this. Something like postman. Here are some others.

And this is a resource I just found but it's by Katalon so it may be a bit self serving. Hope that helps!

Short term you can use PACLI and a spreadsheet, long term I would look at using the available API. psPAS is a great start. postman collection

You can do it but it is not the most fun to do. You have to export the Json files to a folder and run newman on that folder. The issue is it is annoying when anything code changes you have to reexport the json files out of postman and into your folder or repo. That is using this command. https://learning.postman.com/docs/running-collections/using-newman-cli/command-line-integration-with-newman/

$ newman run PostmanCollection.json -e environment.json --bail newman

The below code in your link calls to the collection stored in postman's website. So when you login it will sync your data with their servers. You can then run your collection by calling a link to the synced files on Postman's servers. This also means they have the data located in their cloud which was the problem with our security team.

$ docker run -t postman/newman run "https://www.postman.com/collections/8a0c9bc08f062d12dcda"

I agree with all the swagger comments but in my experience getting a full team to keep the docs updated is not always easy. I've had great experiences using https://www.postman.com/ as Dev tool to test my API endpoints as I go and it will generate full docs from the requests you build in it. You have to pay for the ability to collaborate but it's always been worth it in my own experience. The docs it makes are pretty nice too and are actually written in swagger under the hood so you can export/import quite easily to other doc platforms if you decide it's not for you.

An easy way to see what is happening is to import sys and add print(request.method, sys.stderr) . However, it seems to me that you want to render the page for GET and then when you click the button it "POSTS" or sends data to the backend.

I'm not a frontend expert nor a python expert but take a peek:

https://gist.github.com/HH0718/446ac3cbc6d83e4d99be11977bbb87e2

I recommend getting postman to help you understand your requests. Fairly easy to learn.

You could make an API that returns data in JSON format. You can use Postman to test it out and it will also act as documentation. There would be no frontend involved in making the API and you could even make a CLI program for easier interaction. Maybe something super simple like HTTP endpoints for user sign up, sign in, create a resource, and view the user's resources. You could store temp user data in Redis and more permanent data in a database of your choosing (PostgreSQL, MariaDB, MongoDB, etc.).

Download Postman to test the REST API calls, build requests and inspect responses, and then either recreate the calls using the python requests library, or copy the code samples that Postman will generate for you. Great tool for learning API’s.

You should be able to get it with the HTTP response that the total charts use. If you open the Network Tab of Inspect Element, you will see a lot of HTTP calls to render?parts=.... These can be replicated with non-browser HTTP calls using a tool like Postman.

For example a PUT request to https://public.domo.com/embed/pages/OYPXR/cards/394856180/render?parts=dynamic,summary,annotations&amp;locale=en-US with an X-DOMO-Embed-Token that can be pulled out of your HTTP calls can get you the JSON response for Total Individuals Tested.

From the response you can look at chart.datasources.<data_source_id>.data.rows and iterate through to get each day's values. data_source_id for Total Individuals Tested is rNQZtOay6sOjvR7mastj5_l17iNtPKj4591HGhq16M6DUH4_9CJvjYS9jJKRlQ7v.

I'll take a look this evening after work and see if I can convert the JSON to csv for Total Tests and Total Positive Tests . I was surprised to see the Test data this morning as well. Would be interesting to calculate 7d and 14d moving averages using historical test count data as well.

1. Download Postman
   1. https://www.postman.com
2. Look at the API documentation for your chosen software
   1. There should be examples you can copy into Postman
3. Execute the GET query, receive JSON data
4. Do something with this data, maybe write an application to do this

You can use postman where you can take advantage of their automation features to setup a routine that auths you and saves your token to append to all future requests with single click. When the token expires just run the automated routine again. This blog post goes over it https://blog.postman.com/extracting-data-from-responses-and-chaining-requests/

Did the problem reoccur? (more than once?). If not, forget about it. If it did or does, then you should inspect the rules and or schedules which have been stored on your bridge (by various apps?). Such an inspection requires a tool like Postman (https://www.postman.com/)

Edit: Or reset the entire bridge to get rid of anything unwanted.

Like u/krimpenrik already said, you are mixing up things a little.

Dart (the language) // Flutter (the framework)

So what you want to achieve, could be done with aqueduct for the backend and with flutter for the frontend.

At this point start with the Aqueduct Docs. You'll learn in less than a day, how you can build a REST API service, connected to a database, secured and authenticated by OAuth 2.0.

Also, to test and debug around your local aqueduct, use the very handy tool called Postman. It's free unless you have a bigger team. With Postman you can easily communicate with your REST-API server, learn and dig deeper how things work.

After you feel comfortable with your first local REST API service, go on and build your Flutter app.

I would strongly recommend to start with flutter_bloc. It's an easy to unterstand and clean state management for flutter. I've also started out this way and it helps a ton to unterstand how things work in flutter.

It is very well documented here. Take one of the tutorials of this library and you'll gain the knowledge you need for your project.

Hope this helps you starting out!

Have a great day

So to just dive and get familiar, I'd go to:

https://start.spring.io

Generate a project with web (jar packaging too)

Then write a client to consume an api, like this https://spoonacular.com/food-api

Learn the api by reading the docs and calling it through something like postman https://www.postman.com/

Take the return objects and request json a nd build up your "domain" objects.

Add endpoints to client to meet needs.

Write some controllers so you could call this service from postman to check it out.

If you want a basic desktop application for submitting API calls, download Postman. It is easy and great for one-off commands.

If you want to automate your API calls, try the PowerShell commands that folks have already mentioned.

Are you sure you are getting a response? 30 seconds is the default timeout, so you may just get a timeout from an invalid URL

A 1300-line response doesn't take 30 seconds. It normally goes much faster than that

When dealing with HTTP requests I often use a tool like postman to make sure that I have the URL and request parameters correct. This is much easier than debugging them through code, since HTTP requests are hard to inspect in a debugger

> Half of my APIs have authentication protocols that don't work with the Web.Contents

I put up some information about Web.Contents here: https://gist.github.com/ninmonkey/aab7ceddc3addd3c24c0d27ed976a785#file-powerbi-using-web-apis-in-powerquery-md

When you're on the permission screen, you can choose to use an API key Then Web.Contents will need to set ApiKeyName in Web.Contents. I believe that method lets windows manage storing credentials,

https://docs.microsoft.com/en-us/powerquery-m/web-contents

Other times you need to set Headers in Web.Contents based on the API.

I find it easier to sketch your query using something like powershell, python, or postman Then once the headers and requests are good, convert it to power query.

Depending on your use case, you could have something scrape web requests that saves to csv/excel sheets, that Power Query imports

CORS is enforced by the browser on the client side. There is nothing you need to tell to the server, it is the server that tells the browser "hey you can/can't access this from another origin."

CORS doesn't really even mean anything in the context of the requests module. In a browser you are making an ajax request from a page. The Access-Control-Allow-Origin header tells the browser whether or not it should allow an ajax request to be made from some other webpage url. With a python requests module http request, there is no origin web page. You are just making a request. Use postman to test rather than a browser.

Another troubleshooting suggestion: First use an API Testing Tool like Postman to validate that the API is working or not and if not, troubleshoot it accordingly in Postman.

It's going to save you so much time in the end and you don't have to wonder if it's an Axios issue or maybe the Provider itself.

Just in case: Here's a video to quickly get Postman set up:

Setup Postman for Windows

Setup Postman for Mac

Just to make things clear and save further argument or embarrassment, I'm 99% sure that "postmen" in the original comment is a misspelling and refers to Postman, the name of a commonly-used tool in web development.

This is (one reason) why you're receiving this degree of ire, because you (either the person or the bot, or both) are interjecting based on a misinterpretation due to not understanding the domain. Context can change everything, maybe keep that in mind.

To help to debug similar problems, you can use HTTP client like Postman and manually change the cookies and play with them and observe the HTML. That is usually faster than running the scraper all over again.

That is the correct track. I would look at using something like postman (https://www.postman.com/) which will give you the testing tools needed to develop the two separate parts of the project independently of each other. Get a solid API then choose the best interface solution that fits your needs. I would also suggest JSON Web Tokens as the best method of securing the communication between your API and your interfaces.

The great part about structure is that it makes adding bots, and other systems trivial for you can write them independent of your communication platform. This is actually the method that Slack uses.

This is the exact path we used for our in service messaging system, and it works well.

You can start with downloading Postman ( https://www.postman.com/ ). You then need to create a developer account on your bridge. If you have done that, you can construct, test and save the commands to change the lights using the Lights API (without scenes) or the Scenes API.

When that's working, you can think about your frond end application. Whatever you choose, it has to send the same commands as you did with Postman, so it will be much easier if you follow this route.

Gotcha. My next step would be to manually try that API URL using something like postman. But that may be a little complicated if you’re not comfortable with this kinda stuff (it’s not too bad but you need to figure out the info that needs to be sent in the POST call and include that). Otherwise I’d check with the plugin developer eg on GitHub, perhaps the alarm.com API changed or there’s something specific to your setup

Personally, I would recommend installing Postman and using that to design your API interaction, you can then use Postman to generate the PowerShell required for the request.

Skinny views / Fat models (toptal.com/django/django-top-10-mistakes)

I'd go in this order:

1. Write your models (make sure they're correctly migrated and you can add and delete without any problems) - this could include a model called Orders which contain all your orders from each user (you want a Foreign Key 🔑 to each user), you can also override the User model if need be. I'd add another model for tracking complaints and the type of complaint.
2. Write your views - using DRF you should take advantage of their generic views for any CRUD jobs and feed towards your serializer
3. Write your serializers - connect them to your views, this is the format you want returned (in JSON) to your API
4. Finally create your urls pointing towards you views

I'd recommend testing this on something like Postman (https://www.postman.com/) as it gives a nice UI

If you install Postman ( https://www.postman.com/ ), and create an account, then you can inspect the contents of your bridge. Then you can inspect the rules, software versions, battery levels etc.

In addition to other commenters and to help you save your time:

(instead of trying to catch a bug via Stripe requests itself)

1) Install the Postman.
2) Create a POST-request to your own server to see what it returns.
3) Check your web server software (apache, nginx, etc) logs to determine what causes 500 errors.

I hope this helps a bit.

Postman is a collaboration platform for API development. Postman's features simplify each step of building an API and streamline collaboration so you can create better APIs - faster.

REST API testing tool:- https://www.postman.com/

Download and install Postman ( https://www.postman.com/ ). Go to the settings and disable SSL certificate verification. Use this tool instead of the clip tool the documentation speaks about.

So, it turns out I'm an idiot.
After using Postman to test my API calls, I found a more descriptive error message, which is unfortunately hidden when using Invoke-RESTMethod in PowerShell.
The error message, accompanying the 400 status, was:
"One or more assets in the request are not included in the site configuration"

And indeed, somehow I was POSTing a scan to site 2, for an asset which lives in site 1.
This will teach me to clear my variables, and to not just run snippets from the scripts when testing.